loro-crdt 1.3.5 → 1.4.1

package/web/loro_wasm.d.ts

@@ -155,36 +155,55 @@ interface LoroDoc {
      * ```
      */
     subscribeLocalUpdates(f: (bytes: Uint8Array) => void): () => void
+
     /**
      * Convert the document to a JSON value with a custom replacer function.
-     * 
+     *
      * This method works similarly to `JSON.stringify`'s replacer parameter.
      * The replacer function is called for each value in the document and can transform
      * how values are serialized to JSON.
-     * 
+     *
      * @param replacer - A function that takes a key and value, and returns how that value
-     *                  should be serialized. Similar to JSON.stringify's replacer. 
+     *                  should be serialized. Similar to JSON.stringify's replacer.
      *                  If return undefined, the value will be skipped.
      * @returns The JSON representation of the document after applying the replacer function.
-     * 
+     *
      * @example
      * ```ts
      * const doc = new LoroDoc();
      * const text = doc.getText("text");
      * text.insert(0, "Hello");
      * text.mark({ start: 0, end: 2 }, "bold", true);
-     * 
+     *
      * // Use delta to represent text
      * const json = doc.toJsonWithReplacer((key, value) => {
      *   if (value instanceof LoroText) {
      *     return value.toDelta();
-     *   } 
-     * 
+     *   }
+     *
      *   return value;
      * });
      * ```
      */
     toJsonWithReplacer(replacer: (key: string | index, value: Value | Container) => Value | Container | undefined): Value;
+
+    /**
+     * 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 from - The source frontier to diff from. A frontier represents a consistent version of the document.
+     * @param to - The target frontier to diff to. A frontier represents a consistent version of the document.
+     * @param for_json - Controls the diff format:
+     *                   - If true, returns JsonDiff format suitable for JSON serialization
+     *                   - If false, returns Diff format that shares the same type as LoroEvent
+     *                   - The default value is `true`
+     */
+    diff(from: OpId[], to: OpId[], for_json: false): [ContainerID, Diff][];
+    diff(from: OpId[], to: OpId[], for_json: true): [ContainerID, JsonDiff][];
+    diff(from: OpId[], to: OpId[], for_json: undefined): [ContainerID, JsonDiff][];
+    diff(from: OpId[], to: OpId[], for_json?: boolean): [ContainerID, JsonDiff|Diff][];
 }
 
 /**
@@ -672,6 +691,11 @@ export type ListDiff = {
     diff: Delta<(Value | Container)[]>[];
 };
 
+export type ListJsonDiff = {
+    type: "list";
+    diff: Delta<(Value | JsonContainerID )[]>[];
+};
+
 export type TextDiff = {
     type: "text";
     diff: Delta<string>[];
@@ -682,6 +706,11 @@ export type MapDiff = {
     updated: Record<string, Value | Container | undefined>;
 };
 
+export type MapJsonDiff = {
+    type: "map";
+    updated: Record<string, Value | JsonContainerID | undefined>;
+};
+
 export type TreeDiffItem =
     | {
         target: TreeID;
@@ -717,6 +746,7 @@ export type CounterDiff = {
 };
 
 export type Diff = ListDiff | TextDiff | MapDiff | TreeDiff | CounterDiff;
+export type JsonDiff = ListJsonDiff | TextDiff | MapJsonDiff | CounterDiff | TreeDiff;
 export type Subscription = () => void;
 type NonNullableType<T> = Exclude<T, null | undefined>;
 export type AwarenessListener = (
@@ -1082,7 +1112,7 @@ interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
      *  If the key already exists, its value will be updated. If the key doesn't exist,
      *  a new key-value pair will be created.
      *
-     *  > **Note**: When calling `map.set(key, value)` on a LoroMap, if `map.get(key)` already returns `value`, 
+     *  > **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
@@ -2318,20 +2348,34 @@ export class LoroDoc {
 */
   revertTo(frontiers: ({ peer: PeerID, counter: number })[]): void;
 /**
-* Apply a diff batch to the document
-* @param {Record<ContainerID, Diff>} diff
-*/
-  applyDiff(diff: Record<ContainerID, Diff>): void;
-/**
-* Calculate the differences between two frontiers
+* Apply a batch of diff to the document
 *
-* 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>}
+* A diff batch represents a set of changes between two versions of the document.
+* You can calculate a diff batch using `doc.diff()`.
+*
+* Changes are associated with container IDs. During diff application, if new containers were created in the source
+* document, they will be assigned fresh IDs in the target document. Loro automatically handles remapping these
+* container IDs from their original IDs to the new IDs as the diff is applied.
+*
+* @example
+* ```ts
+* const doc1 = new LoroDoc();
+* const doc2 = new LoroDoc();
+*
+* // Make some changes to doc1
+* const text = doc1.getText("text");
+* text.insert(0, "Hello");
+*
+* // Calculate diff between empty and current state
+* const diff = doc1.diff([], doc1.frontiers());
+*
+* // Apply changes to doc2
+* doc2.applyDiff(diff);
+* console.log(doc2.getText("text").toString()); // "Hello"
+* ```
+* @param {[ContainerID, Diff|JsonDiff][]} diff
 */
-  diff(from: ({ peer: PeerID, counter: number })[], to: ({ peer: PeerID, counter: number })[]): Record<ContainerID, Diff>;
+  applyDiff(diff: [ContainerID, Diff|JsonDiff][]): void;
 /**
 * Peer ID of the current writer.
 */
@@ -3691,7 +3735,7 @@ export interface InitOutput {
   readonly lorodoc_getChangedContainersIn: (a: number, b: number, c: number, d: number) => void;
   readonly lorodoc_revertTo: (a: number, b: number, c: number, d: number) => void;
   readonly lorodoc_applyDiff: (a: number, b: number, c: number) => void;
-  readonly lorodoc_diff: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly lorodoc_diff: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly __wbg_lorotext_free: (a: number) => void;
   readonly lorotext_new: () => number;
   readonly lorotext_kind: (a: number) => number;

package/web/loro_wasm.js

@@ -2602,8 +2602,32 @@ export class LoroDoc {
         }
     }
     /**
-    * Apply a diff batch to the document
-    * @param {Record<ContainerID, Diff>} diff
+    * Apply a batch of diff to the document
+    *
+    * A diff batch represents a set of changes between two versions of the document.
+    * You can calculate a diff batch using `doc.diff()`.
+    *
+    * Changes are associated with container IDs. During diff application, if new containers were created in the source
+    * document, they will be assigned fresh IDs in the target document. Loro automatically handles remapping these
+    * container IDs from their original IDs to the new IDs as the diff is applied.
+    *
+    * @example
+    * ```ts
+    * const doc1 = new LoroDoc();
+    * const doc2 = new LoroDoc();
+    *
+    * // Make some changes to doc1
+    * const text = doc1.getText("text");
+    * text.insert(0, "Hello");
+    *
+    * // Calculate diff between empty and current state
+    * const diff = doc1.diff([], doc1.frontiers());
+    *
+    * // Apply changes to doc2
+    * doc2.applyDiff(diff);
+    * console.log(doc2.getText("text").toString()); // "Hello"
+    * ```
+    * @param {[ContainerID, Diff|JsonDiff][]} diff
     */
     applyDiff(diff) {
         try {
@@ -2625,16 +2649,17 @@ export class LoroDoc {
     * presented before its use.
     * @param {({ peer: PeerID, counter: number })[]} from
     * @param {({ peer: PeerID, counter: number })[]} to
-    * @returns {Record<ContainerID, Diff>}
+    * @param {boolean | undefined} [for_json]
+    * @returns {[ContainerID, Diff|JsonDiff][]}
     */
-    diff(from, to) {
+    diff(from, to, for_json) {
         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);
+            wasm.lorodoc_diff(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(for_json) ? 0xFFFFFF : for_json ? 1 : 0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -6017,32 +6042,32 @@ function __wbg_get_imports() {
         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_lorotext_new = function(arg0) {
-        const ret = LoroText.__wrap(arg0);
+    imports.wbg.__wbg_lorotree_new = function(arg0) {
+        const ret = LoroTree.__wrap(arg0);
         return addHeapObject(ret);
     };
     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);
+    imports.wbg.__wbg_lorocounter_new = function(arg0) {
+        const ret = LoroCounter.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_cursor_new = function(arg0) {
-        const ret = Cursor.__wrap(arg0);
+    imports.wbg.__wbg_loromap_new = function(arg0) {
+        const ret = LoroMap.__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);
+    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);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_versionvector_new = function(arg0) {
@@ -6237,7 +6262,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export_5(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_now_6dd635953150ee31 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+    imports.wbg.__wbg_now_bc6f749123583eb9 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -6501,11 +6526,11 @@ function __wbg_get_imports() {
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_closure_wrapper482 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
+        const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_60);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper484 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
+    imports.wbg.__wbindgen_closure_wrapper485 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_63);
         return addHeapObject(ret);
     };
 

package/web/loro_wasm_bg.wasm.d.ts

@@ -99,7 +99,7 @@ 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 lorodoc_diff(a: number, b: number, c: number, d: number, e: number, f: number, g: number): void;
 export function __wbg_lorotext_free(a: number): void;
 export function lorotext_new(): number;
 export function lorotext_kind(a: number): number;