loro-crdt 1.2.6 → 1.3.0

package/web/loro_wasm.js

@@ -229,11 +229,11 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
-function __wbg_adapter_58(arg0, arg1, arg2) {
+function __wbg_adapter_60(arg0, arg1, arg2) {
     wasm.__wbindgen_export_3(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_61(arg0, arg1) {
+function __wbg_adapter_63(arg0, arg1) {
     wasm.__wbindgen_export_4(arg0, arg1);
 }
 
@@ -963,9 +963,12 @@ export class LoroDoc {
         wasm.lorodoc_setRecordTimestamp(this.__wbg_ptr, auto_record);
     }
     /**
-    * If two continuous local changes are within the interval, they will be merged into one change.
+    * If two continuous local changes are within (<=) the interval(**in seconds**), they will be merged into one change.
     *
-    * The default value is 1_000_000, the default unit is seconds.
+    * The default value is 1_000 seconds.
+    *
+    * By default, we record timestamps in seconds for each change. So if the merge interval is 1, and changes A and B
+    * have timestamps of 3 and 4 respectively, then they will be merged into one change
     * @param {number} interval
     */
     setChangeMergeInterval(interval) {
@@ -1229,6 +1232,72 @@ export class LoroDoc {
         }
     }
     /**
+    * Find the op id spans that between the `from` version and the `to` version.
+    *
+    * You can combine it with `exportJsonInIdSpan` to get the changes between two versions.
+    *
+    * You can use it to travel all the changes from `from` to `to`. `from` and `to` are frontiers,
+    * and they can be concurrent to each other. You can use it to find all the changes related to an event:
+    *
+    * @example
+    * ```ts
+    * import { LoroDoc } from "loro-crdt";
+    *
+    * const docA = new LoroDoc();
+    * docA.setPeerId("1");
+    * const docB = new LoroDoc();
+    *
+    * docA.getText("text").update("Hello");
+    * docA.commit();
+    * const snapshot = docA.export({ mode: "snapshot" });
+    * let done = false;
+    * docB.subscribe(e => {
+    *   const spans = docB.findIdSpansBetween(e.from, e.to);
+    *   const changes = docB.exportJsonInIdSpan(spans.forward[0]);
+    *   console.log(changes);
+    *   // [{
+    *   //   id: "0@1",
+    *   //   timestamp: expect.any(Number),
+    *   //   deps: [],
+    *   //   lamport: 0,
+    *   //   msg: undefined,
+    *   //   ops: [{
+    *   //     container: "cid:root-text:Text",
+    *   //     counter: 0,
+    *   //     content: {
+    *   //       type: "insert",
+    *   //       pos: 0,
+    *   //       text: "Hello"
+    *   //     }
+    *   //   }]
+    *   // }]
+    * });
+    * docB.import(snapshot);
+    * ```
+    * @param {({ peer: PeerID, counter: number })[]} from
+    * @param {({ peer: PeerID, counter: number })[]} to
+    * @returns {VersionVectorDiff}
+    */
+    findIdSpansBetween(from, to) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(from, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(to, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.lorodoc_findIdSpansBetween(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Checkout the `DocState` to a specific version.
     *
     * > The document becomes detached during a `checkout` operation.
@@ -1307,12 +1376,14 @@ export class LoroDoc {
         }
     }
     /**
-    * Commit the cumulative auto committed transaction.
+    * Commit the cumulative auto-committed transaction.
     *
     * You can specify the `origin`, `timestamp`, and `message` of the commit.
     *
     * - The `origin` is used to mark the event
     * - The `message` works like a git commit message, which will be recorded and synced to peers
+    * - The `timestamp` is the number of seconds that have elapsed since 00:00:00 UTC on January 1, 1970.
+    *   It defaults to `Date.now() / 1000` when timestamp recording is enabled
     *
     * The events will be emitted after a transaction is committed. A transaction is committed when:
     *
@@ -1889,12 +1960,32 @@ export class LoroDoc {
     * Export updates in the given range in JSON format.
     * @param {any} start_vv
     * @param {any} end_vv
+    * @param {boolean | undefined} [with_peer_compression]
     * @returns {JsonSchema}
     */
-    exportJsonUpdates(start_vv, end_vv) {
+    exportJsonUpdates(start_vv, end_vv, with_peer_compression) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_exportJsonUpdates(retptr, this.__wbg_ptr, addHeapObject(start_vv), addHeapObject(end_vv), isLikeNone(with_peer_compression) ? 0xFFFFFF : with_peer_compression ? 1 : 0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {{ peer: PeerID, counter: number, length: number }} idSpan
+    * @returns {any}
+    */
+    exportJsonInIdSpan(idSpan) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.lorodoc_exportJsonUpdates(retptr, this.__wbg_ptr, addHeapObject(start_vv), addHeapObject(end_vv));
+            wasm.lorodoc_exportJsonInIdSpan(retptr, this.__wbg_ptr, addHeapObject(idSpan));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -2093,7 +2184,7 @@ export class LoroDoc {
     *
     * @example
     * ```ts
-    * import { LoroDoc, LoroText } from "loro-crdt";
+    * import { LoroDoc, LoroText, LoroMap } from "loro-crdt";
     *
     * const doc = new LoroDoc();
     * const list = doc.getList("list");
@@ -2457,6 +2548,84 @@ export class LoroDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Revert the document to the given frontiers.
+    *
+    * The doc will not become detached when using this method. Instead, it will generate a series
+    * of operations to revert the document to the given version.
+    *
+    * @example
+    * ```ts
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const text = doc.getText("text");
+    * text.insert(0, "Hello");
+    * doc.commit();
+    * doc.revertTo([{ peer: "1", counter: 1 }]);
+    * expect(doc.getText("text").toString()).toBe("He");
+    * ```
+    * @param {({ peer: PeerID, counter: number })[]} frontiers
+    */
+    revertTo(frontiers) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(frontiers, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.lorodoc_revertTo(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Apply a diff batch to the document
+    * @param {Record<ContainerID, Diff>} diff
+    */
+    applyDiff(diff) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_applyDiff(retptr, this.__wbg_ptr, addHeapObject(diff));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Calculate the differences between two frontiers
+    *
+    * The entries in the returned object are sorted by causal order: the creation of a child container will be
+    * presented before its use.
+    * @param {({ peer: PeerID, counter: number })[]} from
+    * @param {({ peer: PeerID, counter: number })[]} to
+    * @returns {Record<ContainerID, Diff>}
+    */
+    diff(from, to) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(from, wasm.__wbindgen_export_0);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayJsValueToWasm0(to, wasm.__wbindgen_export_0);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.lorodoc_diff(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const LoroListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3354,7 +3523,7 @@ export class LoroMap {
     *
     * @example
     * ```ts
-    * import { LoroDoc } from "loro-crdt";
+    * import { LoroDoc, LoroText } from "loro-crdt";
     *
     * const doc = new LoroDoc();
     * doc.setPeerId("1");
@@ -5168,26 +5337,6 @@ export class LoroTreeNode {
         }
     }
     /**
-    * Move this tree node to be a child of the parent.
-    * If the parent is undefined, this node will be a root node.
-    *
-    * If the index is not provided, the node will be appended to the end.
-    *
-    * It's not allowed that the target is an ancestor of the parent.
-    *
-    * @example
-    * ```ts
-    * const doc = new LoroDoc();
-    * const tree = doc.getTree("tree");
-    * const root = tree.createNode();
-    * const node = root.createNode();
-    * const node2 = node.createNode();
-    * node2.move(undefined, 0);
-    * // node2   root
-    * //          |
-    * //         node
-    *
-    * ```
     * @param {LoroTreeNode | undefined} parent
     * @param {number | undefined} [index]
     */
@@ -5350,11 +5499,6 @@ export class LoroTreeNode {
         }
     }
     /**
-    * Get the parent node of this node.
-    *
-    * - The parent of the root node is `undefined`.
-    * - The object returned is a new js object each time because it need to cross
-    *   the WASM boundary.
     * @returns {LoroTreeNode | undefined}
     */
     parent() {
@@ -5552,6 +5696,7 @@ export class UndoManager {
     }
     /**
     * Set the merge interval (in ms).
+    *
     * If the interval is set to 0, the undo steps will not be merged.
     * Otherwise, the undo steps will be merged if the interval between the two steps is less than the given interval.
     * @param {number} interval
@@ -5858,36 +6003,36 @@ function __wbg_get_imports() {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.__wbg_loromap_new = function(arg0) {
-        const ret = LoroMap.__wrap(arg0);
+    imports.wbg.__wbg_lorolist_new = function(arg0) {
+        const ret = LoroList.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotext_new = function(arg0) {
-        const ret = LoroText.__wrap(arg0);
+    imports.wbg.__wbg_lorocounter_new = function(arg0) {
+        const ret = LoroCounter.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorolist_new = function(arg0) {
-        const ret = LoroList.__wrap(arg0);
+    imports.wbg.__wbg_loromap_new = function(arg0) {
+        const ret = LoroMap.__wrap(arg0);
         return addHeapObject(ret);
     };
-    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_cursor_new = function(arg0) {
-        const ret = Cursor.__wrap(arg0);
+    imports.wbg.__wbg_lorotree_new = function(arg0) {
+        const ret = LoroTree.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_loromovablelist_new = function(arg0) {
         const ret = LoroMovableList.__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_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_versionvector_new = function(arg0) {
@@ -5983,6 +6128,10 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_is_array = function(arg0) {
+        const ret = Array.isArray(getObject(arg0));
+        return ret;
+    };
     imports.wbg.__wbindgen_typeof = function(arg0) {
         const ret = typeof getObject(arg0);
         return addHeapObject(ret);
@@ -6078,7 +6227,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export_5(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_now_11683c634f92ae89 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+    imports.wbg.__wbg_now_15d99db1ebc1f0b2 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -6184,6 +6333,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
+    imports.wbg.__wbg_from_89e3fc3ba5e6fb48 = function(arg0) {
+        const ret = Array.from(getObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_isArray_2ab64d95e09ea0ae = function(arg0) {
         const ret = Array.isArray(getObject(arg0));
         return ret;
@@ -6337,12 +6490,12 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper487 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_58);
+    imports.wbg.__wbindgen_closure_wrapper491 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 9, __wbg_adapter_60);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper489 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_61);
+    imports.wbg.__wbindgen_closure_wrapper494 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 11, __wbg_adapter_63);
         return addHeapObject(ret);
     };
 

package/web/loro_wasm_bg.wasm.d.ts

@@ -44,6 +44,7 @@ export function lorodoc_fork(a: number): number;
 export function lorodoc_forkAt(a: number, b: number, c: number, d: number): void;
 export function lorodoc_checkoutToLatest(a: number, b: number): void;
 export function lorodoc_travelChangeAncestors(a: number, b: number, c: number, d: number, e: number): void;
+export function lorodoc_findIdSpansBetween(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function lorodoc_checkout(a: number, b: number, c: number, d: number): void;
 export function lorodoc_peerId(a: number): number;
 export function lorodoc_peerIdStr(a: number): number;
@@ -73,7 +74,8 @@ export function lorodoc_cmpFrontiers(a: number, b: number, c: number, d: number,
 export function lorodoc_exportSnapshot(a: number, b: number): void;
 export function lorodoc_exportFrom(a: number, b: number, c: number): void;
 export function lorodoc_export(a: number, b: number, c: number): void;
-export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: number): void;
+export function lorodoc_exportJsonUpdates(a: number, b: number, c: number, d: number, e: number): void;
+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;
@@ -94,6 +96,9 @@ export function lorodoc_vvToFrontiers(a: number, b: number, c: number): void;
 export function lorodoc_getByPath(a: number, b: number, c: number): number;
 export function lorodoc_getCursorPos(a: number, b: number, c: number): void;
 export function lorodoc_getChangedContainersIn(a: number, b: number, c: number, d: number): void;
+export function lorodoc_revertTo(a: number, b: number, c: number, d: number): void;
+export function lorodoc_applyDiff(a: number, b: number, c: number): void;
+export function lorodoc_diff(a: number, b: number, c: number, d: number, e: number, f: number): void;
 export function __wbg_lorotext_free(a: number): void;
 export function lorotext_new(): number;
 export function lorotext_kind(a: number): number;