loro-crdt 1.2.1 → 1.2.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.2.2
+
+### Patch Changes
+
+- 3b7a738: Add getShallowValue and toJsonWIthReplacer
+
+  - Add getShallowValue for each container (#581)
+  - Implement toJsonWithReplacer method for LoroDoc to customize JSON serialization (#582)
+  - Rename importUpdateBatch into importBatch & refine type (#580)
+
 ## 1.2.1
 
 ### Patch Changes

package/base64/index.js

@@ -861,6 +861,14 @@ class LoroCounter {
         const ret = wasm.lorocounter_getAttached(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+    * Get the value of the counter.
+    * @returns {number}
+    */
+    getShallowValue() {
+        const ret = wasm.lorocounter_getShallowValue(this.__wbg_ptr);
+        return ret;
+    }
 }
 
 const LoroDocFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -1987,10 +1995,12 @@ class LoroDoc {
         }
     }
     /**
-    * Import a batch of updates.
+    * Import a batch of updates and snapshots.
     *
     * It's more efficient than importing updates one by one.
     *
+    * @deprecated Use `importBatch` instead.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -2001,9 +2011,9 @@ class LoroDoc {
     * const updates = doc.export({ mode: "update" });
     * const snapshot = doc.export({ mode: "snapshot" });
     * const doc2 = new LoroDoc();
-    * doc2.importUpdateBatch([snapshot, updates]);
+    * doc2.importBatch([snapshot, updates]);
     * ```
-    * @param {Array<any>} data
+    * @param {Uint8Array[]} data
     * @returns {ImportStatus}
     */
     importUpdateBatch(data) {
@@ -2022,8 +2032,46 @@ class LoroDoc {
         }
     }
     /**
+    * Import a batch of updates or snapshots.
+    *
+    * It's more efficient than importing updates one by one.
+    *
+    * @example
+    * ```ts
+    * import { LoroDoc } from "loro-crdt";
+    *
+    * const doc = new LoroDoc();
+    * const text = doc.getText("text");
+    * text.insert(0, "Hello");
+    * const updates = doc.export({ mode: "update" });
+    * const snapshot = doc.export({ mode: "snapshot" });
+    * const doc2 = new LoroDoc();
+    * doc2.importBatch([snapshot, updates]);
+    * ```
+    * @param {Uint8Array[]} data
+    * @returns {ImportStatus}
+    */
+    importBatch(data) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
     * Get the shallow json format of the document state.
     *
+    * Unlike `toJSON()` which recursively resolves all containers to their values,
+    * `getShallowValue()` returns container IDs as strings for any nested containers.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -2033,12 +2081,17 @@ class LoroDoc {
     * const tree = doc.getTree("tree");
     * const map = doc.getMap("map");
     * const shallowValue = doc.getShallowValue();
-    * /*
-    * {"list": ..., "tree": ..., "map": ...}
-    *  *\/
     * console.log(shallowValue);
+    * // {
+    * //   list: 'cid:root-list:List',
+    * //   tree: 'cid:root-tree:Tree',
+    * //   map: 'cid:root-map:Map'
+    * // }
+    *
+    * // It points to the same container as `list`
+    * const listB = doc.getContainerById(shallowValue.list);
     * ```
-    * @returns {any}
+    * @returns {Record<string, ContainerID>}
     */
     getShallowValue() {
         try {
@@ -2058,9 +2111,12 @@ class LoroDoc {
     /**
     * Get the json format of the entire document state.
     *
+    * Unlike `getShallowValue()` which returns container IDs as strings,
+    * `toJSON()` recursively resolves all containers to their actual values.
+    *
     * @example
     * ```ts
-    * import { LoroDoc, LoroText, LoroMap } from "loro-crdt";
+    * import { LoroDoc, LoroText } from "loro-crdt";
     *
     * const doc = new LoroDoc();
     * const list = doc.getList("list");
@@ -2069,10 +2125,8 @@ class LoroDoc {
     * text.insert(0, "Hello");
     * const map = list.insertContainer(1, new LoroMap());
     * map.set("foo", "bar");
-    * /*
-    * {"list": ["Hello", {"foo": "bar"}]}
-    *  *\/
     * console.log(doc.toJSON());
+    * // {"list": ["Hello", {"foo": "bar"}]}
     * ```
     * @returns {any}
     */
@@ -2827,6 +2881,29 @@ class LoroList {
         const ret = wasm.lorolist_isDeleted(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Get the shallow value of the list.
+    *
+    * Unlike `toJSON()` which recursively resolves all containers to their values,
+    * `getShallowValue()` returns container IDs as strings for any nested containers.
+    *
+    * ```js
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const list = doc.getList("list");
+    * list.insert(0, 1);
+    * list.insert(1, "two");
+    * const subList = list.insertContainer(2, new LoroList());
+    * subList.insert(0, "sub");
+    * list.getShallowValue(); // [1, "two", "cid:2@1:List"]
+    * list.toJSON(); // [1, "two", ["sub"]]
+    * ```
+    * @returns {Value[]}
+    */
+    getShallowValue() {
+        const ret = wasm.lorolist_getShallowValue(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
 const LoroMapFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3277,6 +3354,37 @@ class LoroMap {
         const ret = wasm.loromap_isDeleted(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Get the shallow value of the map.
+    *
+    * Unlike `toJSON()` which recursively resolves all containers to their values,
+    * `getShallowValue()` returns container IDs as strings for any nested containers.
+    *
+    * @example
+    * ```ts
+    * import { LoroDoc } from "loro-crdt";
+    *
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const map = doc.getMap("map");
+    * map.set("key", "value");
+    * const subText = map.setContainer("text", new LoroText());
+    * subText.insert(0, "Hello");
+    *
+    * // Get shallow value - nested containers are represented by their IDs
+    * console.log(map.getShallowValue());
+    * // Output: { key: "value", text: "cid:1@1:Text" }
+    *
+    * // Get full value with nested containers resolved by `toJSON()`
+    * console.log(map.toJSON());
+    * // Output: { key: "value", text: "Hello" }
+    * ```
+    * @returns {Record<string, Value>}
+    */
+    getShallowValue() {
+        const ret = wasm.loromap_getShallowValue(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
 const LoroMovableListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3784,6 +3892,29 @@ class LoroMovableList {
         const ret = wasm.loromovablelist_isDeleted(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Get the shallow value of the movable list.
+    *
+    * Unlike `toJSON()` which recursively resolves all containers to their values,
+    * `getShallowValue()` returns container IDs as strings for any nested containers.
+    *
+    * ```js
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const list = doc.getMovableList("list");
+    * list.insert(0, 1);
+    * list.insert(1, "two");
+    * const subList = list.insertContainer(2, new LoroList());
+    * subList.insert(0, "sub");
+    * list.getShallowValue(); // [1, "two", "cid:2@1:List"]
+    * list.toJSON(); // [1, "two", ["sub"]]
+    * ```
+    * @returns {Value[]}
+    */
+    getShallowValue() {
+        const ret = wasm.loromovablelist_getShallowValue(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
 const LoroTextFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4439,6 +4570,26 @@ class LoroText {
         const ret = wasm.lorotext_isDeleted(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Get the shallow value of the text. This equals to `text.toString()`.
+    * @returns {string}
+    */
+    getShallowValue() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorotext_getShallowValue(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_5(deferred1_0, deferred1_1, 1);
+        }
+    }
 }
 
 const LoroTreeFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4886,6 +5037,51 @@ class LoroTree {
         const ret = wasm.lorotree_isDeleted(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Get the shallow value of the tree.
+    *
+    * Unlike `toJSON()` which recursively resolves nested containers to their values,
+    * `getShallowValue()` returns container IDs as strings for any nested containers.
+    *
+    * @example
+    * ```ts
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const tree = doc.getTree("tree");
+    * const root = tree.createNode();
+    * root.data.set("name", "root");
+    * const text = root.data.setContainer("content", new LoroText());
+    * text.insert(0, "Hello");
+    *
+    * console.log(tree.getShallowValue());
+    * // [{
+    * //   id: "0@1",
+    * //   parent: null,
+    * //   index: 0,
+    * //   fractional_index: "80",
+    * //   meta: "cid:0@1:Map",
+    * //   children: []
+    * // }]
+    *
+    * console.log(tree.toJSON());
+    * // [{
+    * //   id: "0@1",
+    * //   parent: null,
+    * //   index: 0,
+    * //   fractional_index: "80",
+    * //   meta: {
+    * //     name: "root",
+    * //     content: "Hello"
+    * //   },
+    * //   children: []
+    * // }]
+    * ```
+    * @returns {TreeNodeShallowValue[]}
+    */
+    getShallowValue() {
+        const ret = wasm.lorotree_getShallowValue(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
 const LoroTreeNodeFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -6257,7 +6453,7 @@ var imports = /*#__PURE__*/Object.freeze({
 // Without this patch, Cloudflare Worker would raise issue like: "Uncaught TypeError: wasm2.__wbindgen_start is not a function"
 
 
-import loro_wasm_bg_js from './loro_wasm_bg-101e42d1.js';
+import loro_wasm_bg_js from './loro_wasm_bg-8056e30c.js';
 const instance = new WebAssembly.Instance(loro_wasm_bg_js(), {
     "./loro_wasm_bg.js": imports,
 });
@@ -6414,5 +6610,52 @@ class Awareness {
         }, this.timeout / 2);
     }
 }
+LoroDoc.prototype.toJsonWithReplacer = function (replacer) {
+    const doc = this;
+    const m = (key, value) => {
+        if (typeof value === "string") {
+            if (isContainerId(value)) {
+                const container = doc.getContainerById(value);
+                if (container == null) {
+                    throw new Error(`ContainerID not found: ${value}`);
+                }
+                const ans = replacer(key, container);
+                if (ans === container) {
+                    const ans = container.getShallowValue();
+                    if (typeof ans === "object") {
+                        return run(ans);
+                    }
+                    return ans;
+                }
+                if (isContainer(ans)) {
+                    throw new Error("Using new container is not allowed in toJsonWithReplacer");
+                }
+                return ans;
+            }
+        }
+        const ans = replacer(key, value);
+        if (isContainer(ans)) {
+            throw new Error("Using new container is not allowed in toJsonWithReplacer");
+        }
+        return ans;
+    };
+    const run = (layer) => {
+        if (Array.isArray(layer)) {
+            return layer.map((item, index) => {
+                return m(index, item);
+            }).filter((item) => item !== undefined);
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(layer)) {
+            const ans = m(key, value);
+            if (ans !== undefined) {
+                result[key] = ans;
+            }
+        }
+        return result;
+    };
+    const layer = this.getShallowValue();
+    return run(layer);
+};
 
 export { Awareness, AwarenessWasm, Cursor, Loro, LoroCounter, LoroDoc, LoroList, LoroMap, LoroMovableList, LoroText, LoroTree, LoroTreeNode, UndoManager, VersionVector, __wbg_String_b9412f8799faab3e, __wbg_apply_0a5aa603881e6d79, __wbg_buffer_12d079cc21e14bdb, __wbg_call_27c0f87801dedf93, __wbg_call_8e7cb608789c2528, __wbg_call_938992c832f74314, __wbg_call_b3ca7c6051f9bec1, __wbg_crypto_1d1f22824a6a080c, __wbg_cursor_new, __wbg_done_298b57d23c0fc80c, __wbg_entries_95cc2c823b285a09, __wbg_entries_ce844941d0c51880, __wbg_error_c8c2cca30a630316, __wbg_error_f851667af71bcfc6, __wbg_getRandomValues_3aa56aa6edec874c, __wbg_get_bd8e338fbd5f5cc8, __wbg_get_e3c254076557e348, __wbg_getindex_03d06b4e7ea3475e, __wbg_getwithrefkey_edc2c8960f0f1191, __wbg_globalThis_d1e6af4856ba331b, __wbg_global_207b558942527489, __wbg_instanceof_ArrayBuffer_836825be07d4c9d2, __wbg_instanceof_Map_87917e0a7aaf4012, __wbg_instanceof_Object_71ca3c0a59266746, __wbg_instanceof_Uint8Array_2b3bbecd033d19f6, __wbg_isArray_2ab64d95e09ea0ae, __wbg_isSafeInteger_f7b04ef02296c4d2, __wbg_iterator_2cee6dadfd956dfa, __wbg_length_c20a40f15020d68a, __wbg_length_cd7af8117672b8b8, __wbg_log_aba5996d9bde071f, __wbg_log_c9486ca5d8e2cbe8, __wbg_log_d8fdbde28117925d, __wbg_lorocounter_new, __wbg_lorolist_new, __wbg_loromap_new, __wbg_loromovablelist_new, __wbg_lorotext_new, __wbg_lorotree_new, __wbg_lorotreenode_new, __wbg_mark_40e050a77cc39fea, __wbg_measure_aa7a73f17813f708, __wbg_msCrypto_eb05e62b530a1508, __wbg_new_16b304a2cfa7ff4a, __wbg_new_63b92bc8671ed464, __wbg_new_72fb9a18b5ae2624, __wbg_new_abda76e883ba8a5f, __wbg_new_d9bc3a0147634640, __wbg_newnoargs_e258087cd0daa0ea, __wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb, __wbg_newwithlength_66ae46612e7f0234, __wbg_newwithlength_e9b4878cebadb3d3, __wbg_next_196c84450b364254, __wbg_next_40fc327bfc8770e6, __wbg_node_104a2ff8d6ea03a2, __wbg_now_11683c634f92ae89, __wbg_ownKeys_658942b7f28d1fe9, __wbg_process_4a72847cc503995b, __wbg_push_a5b05aedc7234f9f, __wbg_randomFillSync_5c9c955aa56b6049, __wbg_require_cca90b1a94a0255b, __wbg_resolve_b0083a7967828ec8, __wbg_self_ce0dbfc45cf2f5be, __wbg_set_1f9b04f170055d33, __wbg_set_8417257aaedc936b, __wbg_set_a47bac70306a19a7, __wbg_set_d4638f722068f043, __wbg_set_f975102236d3c502, __wbg_set_wasm, __wbg_setindex_0b7ede192dc5eca8, __wbg_stack_658279fe44541cf6, __wbg_subarray_a1f73cd4b5b42fe1, __wbg_then_0c86a60e8fcfe9f6, __wbg_value_d93c65011f51a456, __wbg_versions_f686565e586dd935, __wbg_versionvector_new, __wbg_window_c6fb939a7f436783, __wbindgen_as_number, __wbindgen_bigint_from_i64, __wbindgen_bigint_from_u64, __wbindgen_bigint_get_as_i64, __wbindgen_boolean_get, __wbindgen_cb_drop, __wbindgen_closure_wrapper487, __wbindgen_closure_wrapper489, __wbindgen_debug_string, __wbindgen_error_new, __wbindgen_in, __wbindgen_is_bigint, __wbindgen_is_falsy, __wbindgen_is_function, __wbindgen_is_null, __wbindgen_is_object, __wbindgen_is_string, __wbindgen_is_undefined, __wbindgen_jsval_eq, __wbindgen_jsval_loose_eq, __wbindgen_memory, __wbindgen_number_get, __wbindgen_number_new, __wbindgen_object_clone_ref, __wbindgen_object_drop_ref, __wbindgen_rethrow, __wbindgen_string_get, __wbindgen_string_new, __wbindgen_throw, __wbindgen_typeof, decodeFrontiers, decodeImportBlobMeta, encodeFrontiers, getType, isContainer, isContainerId, newContainerID, newRootContainerID, run, setDebug };