loro-crdt 1.4.1 → 1.4.3

package/bundler/loro_wasm.d.ts

@@ -1,6 +1,11 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
+* Get the version of Loro
+* @returns {string}
+*/
+export function LORO_VERSION(): string;
+/**
 */
 export function run(): void;
 /**
@@ -109,7 +114,7 @@ interface LoroDoc {
      *  text = doc.getContainerById(textId);
      *  ```
      */
-    getContainerById(id: ContainerID): Container;
+    getContainerById(id: ContainerID): Container | undefined;
 
     /**
      * Subscribe to updates from local edits.
@@ -1859,6 +1864,8 @@ export class LoroDoc {
 * The object returned is a new js object each time because it need to cross
 * the WASM boundary.
 *
+* If the container does not exist, an error will be thrown.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt";
@@ -1872,16 +1879,67 @@ export class LoroDoc {
   getText(cid: ContainerID | string): LoroText;
 /**
 * Get a LoroCounter by container id
+*
+* If the container does not exist, an error will be thrown.
 * @param {ContainerID | string} cid
 * @returns {LoroCounter}
 */
   getCounter(cid: ContainerID | string): LoroCounter;
 /**
+* Check if the doc contains the target container.
+*
+* A root container always exists, while a normal container exists
+* if it has ever been created on the doc.
+*
+* @example
+* ```ts
+* import { LoroDoc, LoroMap, LoroText, LoroList } from "loro-crdt";
+*
+* const doc = new LoroDoc();
+* doc.setPeerId("1");
+* const text = doc.getMap("map").setContainer("text", new LoroText());
+* const list = doc.getMap("map").setContainer("list", new LoroList());
+* expect(doc.isContainerExists("cid:root-map:Map")).toBe(true);
+* expect(doc.isContainerExists("cid:0@1:Text")).toBe(true);
+* expect(doc.isContainerExists("cid:1@1:List")).toBe(true);
+*
+* const doc2 = new LoroDoc();
+* // Containers exist, as long as the history or the doc state include it
+* doc.detach();
+* doc2.import(doc.export({ mode: "update" }));
+* expect(doc2.isContainerExists("cid:root-map:Map")).toBe(true);
+* expect(doc2.isContainerExists("cid:0@1:Text")).toBe(true);
+* expect(doc2.isContainerExists("cid:1@1:List")).toBe(true);
+* ```
+* @param {ContainerID} container_id
+* @returns {boolean}
+*/
+  hasContainer(container_id: ContainerID): boolean;
+/**
 * Set the commit message of the next commit
 * @param {string} msg
 */
   setNextCommitMessage(msg: string): void;
 /**
+* Set the origin of the next commit
+* @param {string} origin
+*/
+  setNextCommitOrigin(origin: string): void;
+/**
+* Set the timestamp of the next commit
+* @param {number} timestamp
+*/
+  setNextCommitTimestamp(timestamp: number): void;
+/**
+* Set the options of the next commit
+* @param {{ origin?: string, timestamp?: number, message?: string }} options
+*/
+  setNextCommitOptions(options: { origin?: string, timestamp?: number, message?: string }): void;
+/**
+* Clear the options of the next commit
+*/
+  clearNextCommitOptions(): void;
+/**
 * Get deep value of the document with container id
 * @returns {any}
 */

package/bundler/loro_wasm_bg.js

@@ -276,6 +276,27 @@ function getArrayJsValueFromWasm0(ptr, len) {
     }
     return result;
 }
+/**
+* Get the version of Loro
+* @returns {string}
+*/
+export function LORO_VERSION() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.LORO_VERSION(retptr);
+        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);
+    }
+}
+
 /**
 */
 export function run() {
@@ -1457,6 +1478,8 @@ export class LoroDoc {
     * The object returned is a new js object each time because it need to cross
     * the WASM boundary.
     *
+    * If the container does not exist, an error will be thrown.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -1489,6 +1512,8 @@ export class LoroDoc {
     * The object returned is a new js object each time because it need to cross
     * the WASM boundary.
     *
+    * If the container does not exist, an error will be thrown.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -1521,6 +1546,8 @@ export class LoroDoc {
     * The object returned is a new js object each time because it need to cross
     * the WASM boundary.
     *
+    * If the container does not exist, an error will be thrown.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -1553,6 +1580,8 @@ export class LoroDoc {
     * The object returned is a new js object each time because it need to cross
     * the WASM boundary.
     *
+    * If the container does not exist, an error will be thrown.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -1581,6 +1610,8 @@ export class LoroDoc {
     }
     /**
     * Get a LoroCounter by container id
+    *
+    * If the container does not exist, an error will be thrown.
     * @param {ContainerID | string} cid
     * @returns {LoroCounter}
     */
@@ -1606,6 +1637,8 @@ export class LoroDoc {
     * The object returned is a new js object each time because it need to cross
     * the WASM boundary.
     *
+    * If the container does not exist, an error will be thrown.
+    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -1633,8 +1666,42 @@ export class LoroDoc {
         }
     }
     /**
-    * Get the container corresponding to the container id
+    * Check if the doc contains the target container.
     *
+    * A root container always exists, while a normal container exists
+    * if it has ever been created on the doc.
+    *
+    * @example
+    * ```ts
+    * import { LoroDoc, LoroMap, LoroText, LoroList } from "loro-crdt";
+    *
+    * const doc = new LoroDoc();
+    * doc.setPeerId("1");
+    * const text = doc.getMap("map").setContainer("text", new LoroText());
+    * const list = doc.getMap("map").setContainer("list", new LoroList());
+    * expect(doc.isContainerExists("cid:root-map:Map")).toBe(true);
+    * expect(doc.isContainerExists("cid:0@1:Text")).toBe(true);
+    * expect(doc.isContainerExists("cid:1@1:List")).toBe(true);
+    *
+    * const doc2 = new LoroDoc();
+    * // Containers exist, as long as the history or the doc state include it
+    * doc.detach();
+    * doc2.import(doc.export({ mode: "update" }));
+    * expect(doc2.isContainerExists("cid:root-map:Map")).toBe(true);
+    * expect(doc2.isContainerExists("cid:0@1:Text")).toBe(true);
+    * expect(doc2.isContainerExists("cid:1@1:List")).toBe(true);
+    * ```
+    * @param {ContainerID} container_id
+    * @returns {boolean}
+    */
+    hasContainer(container_id) {
+        const ret = wasm.lorodoc_hasContainer(this.__wbg_ptr, addHeapObject(container_id));
+        return ret !== 0;
+    }
+    /**
+    * Get the container corresponding to the container id.
+    *
+    * If the container does not exist, it returns `undefined`.
     *
     * @example
     * ```ts
@@ -1673,6 +1740,45 @@ export class LoroDoc {
         wasm.lorodoc_setNextCommitMessage(this.__wbg_ptr, ptr0, len0);
     }
     /**
+    * Set the origin of the next commit
+    * @param {string} origin
+    */
+    setNextCommitOrigin(origin) {
+        const ptr0 = passStringToWasm0(origin, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.lorodoc_setNextCommitOrigin(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    * Set the timestamp of the next commit
+    * @param {number} timestamp
+    */
+    setNextCommitTimestamp(timestamp) {
+        wasm.lorodoc_setNextCommitTimestamp(this.__wbg_ptr, timestamp);
+    }
+    /**
+    * Set the options of the next commit
+    * @param {{ origin?: string, timestamp?: number, message?: string }} options
+    */
+    setNextCommitOptions(options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_setNextCommitOptions(retptr, this.__wbg_ptr, addHeapObject(options));
+            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);
+        }
+    }
+    /**
+    * Clear the options of the next commit
+    */
+    clearNextCommitOptions() {
+        wasm.lorodoc_clearNextCommitOptions(this.__wbg_ptr);
+    }
+    /**
     * Get deep value of the document with container id
     * @returns {any}
     */
@@ -6013,28 +6119,33 @@ export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 };
 
+export function __wbg_lorocounter_new(arg0) {
+    const ret = LoroCounter.__wrap(arg0);
+    return addHeapObject(ret);
+};
+
 export function __wbg_lorotreenode_new(arg0) {
     const ret = LoroTreeNode.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotree_new(arg0) {
-    const ret = LoroTree.__wrap(arg0);
+export function __wbg_cursor_new(arg0) {
+    const ret = Cursor.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorolist_new(arg0) {
-    const ret = LoroList.__wrap(arg0);
+export function __wbg_loromap_new(arg0) {
+    const ret = LoroMap.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_lorocounter_new(arg0) {
-    const ret = LoroCounter.__wrap(arg0);
+export function __wbg_lorotext_new(arg0) {
+    const ret = LoroText.__wrap(arg0);
     return addHeapObject(ret);
 };
 
-export function __wbg_loromap_new(arg0) {
-    const ret = LoroMap.__wrap(arg0);
+export function __wbg_lorotree_new(arg0) {
+    const ret = LoroTree.__wrap(arg0);
     return addHeapObject(ret);
 };
 
@@ -6043,13 +6154,8 @@ export function __wbg_loromovablelist_new(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_lorotext_new(arg0) {
-    const ret = LoroText.__wrap(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);
 };
 
@@ -6281,7 +6387,7 @@ export function __wbg_error_f851667af71bcfc6(arg0, arg1) {
     }
 };
 
-export const __wbg_now_bc6f749123583eb9 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+export const __wbg_now_cd30a09c9b727b65 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
 
 export function __wbg_crypto_1d1f22824a6a080c(arg0) {
     const ret = getObject(arg0).crypto;
@@ -6606,12 +6712,12 @@ export function __wbindgen_memory() {
 };
 
 export function __wbindgen_closure_wrapper482(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_60);
+    const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
     return addHeapObject(ret);
 };
 
 export function __wbindgen_closure_wrapper485(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_63);
+    const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
     return addHeapObject(ret);
 };
 

package/bundler/loro_wasm_bg.wasm.d.ts

@@ -27,6 +27,7 @@ export function awarenesswasm_removeOutdated(a: number, b: number): void;
 export function awarenesswasm_length(a: number): number;
 export function awarenesswasm_isEmpty(a: number): number;
 export function awarenesswasm_peers(a: number, b: number): void;
+export function LORO_VERSION(a: number): void;
 export function run(): void;
 export function encodeFrontiers(a: number, b: number, c: number): void;
 export function decodeFrontiers(a: number, b: number, c: number): void;
@@ -59,8 +60,13 @@ export function lorodoc_getList(a: number, b: number, c: number): void;
 export function lorodoc_getMovableList(a: number, b: number, c: number): void;
 export function lorodoc_getCounter(a: number, b: number, c: number): void;
 export function lorodoc_getTree(a: number, b: number, c: number): void;
+export function lorodoc_hasContainer(a: number, b: number): number;
 export function lorodoc_getContainerById(a: number, b: number, c: number): void;
 export function lorodoc_setNextCommitMessage(a: number, b: number, c: number): void;
+export function lorodoc_setNextCommitOrigin(a: number, b: number, c: number): void;
+export function lorodoc_setNextCommitTimestamp(a: number, b: number): void;
+export function lorodoc_setNextCommitOptions(a: number, b: number, c: number): void;
+export function lorodoc_clearNextCommitOptions(a: number): void;
 export function lorodoc_getDeepValueWithID(a: number): number;
 export function lorodoc_getPathToContainer(a: number, b: number, c: number): void;
 export function lorodoc_JSONPath(a: number, b: number, c: number, d: number): void;

package/nodejs/loro_wasm.d.ts

@@ -1,6 +1,11 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
+* Get the version of Loro
+* @returns {string}
+*/
+export function LORO_VERSION(): string;
+/**
 */
 export function run(): void;
 /**
@@ -109,7 +114,7 @@ interface LoroDoc {
      *  text = doc.getContainerById(textId);
      *  ```
      */
-    getContainerById(id: ContainerID): Container;
+    getContainerById(id: ContainerID): Container | undefined;
 
     /**
      * Subscribe to updates from local edits.
@@ -1859,6 +1864,8 @@ export class LoroDoc {
 * The object returned is a new js object each time because it need to cross
 * the WASM boundary.
 *
+* If the container does not exist, an error will be thrown.
+*
 * @example
 * ```ts
 * import { LoroDoc } from "loro-crdt";
@@ -1872,16 +1879,67 @@ export class LoroDoc {
   getText(cid: ContainerID | string): LoroText;
 /**
 * Get a LoroCounter by container id
+*
+* If the container does not exist, an error will be thrown.
 * @param {ContainerID | string} cid
 * @returns {LoroCounter}
 */
   getCounter(cid: ContainerID | string): LoroCounter;
 /**
+* Check if the doc contains the target container.
+*
+* A root container always exists, while a normal container exists
+* if it has ever been created on the doc.
+*
+* @example
+* ```ts
+* import { LoroDoc, LoroMap, LoroText, LoroList } from "loro-crdt";
+*
+* const doc = new LoroDoc();
+* doc.setPeerId("1");
+* const text = doc.getMap("map").setContainer("text", new LoroText());
+* const list = doc.getMap("map").setContainer("list", new LoroList());
+* expect(doc.isContainerExists("cid:root-map:Map")).toBe(true);
+* expect(doc.isContainerExists("cid:0@1:Text")).toBe(true);
+* expect(doc.isContainerExists("cid:1@1:List")).toBe(true);
+*
+* const doc2 = new LoroDoc();
+* // Containers exist, as long as the history or the doc state include it
+* doc.detach();
+* doc2.import(doc.export({ mode: "update" }));
+* expect(doc2.isContainerExists("cid:root-map:Map")).toBe(true);
+* expect(doc2.isContainerExists("cid:0@1:Text")).toBe(true);
+* expect(doc2.isContainerExists("cid:1@1:List")).toBe(true);
+* ```
+* @param {ContainerID} container_id
+* @returns {boolean}
+*/
+  hasContainer(container_id: ContainerID): boolean;
+/**
 * Set the commit message of the next commit
 * @param {string} msg
 */
   setNextCommitMessage(msg: string): void;
 /**
+* Set the origin of the next commit
+* @param {string} origin
+*/
+  setNextCommitOrigin(origin: string): void;
+/**
+* Set the timestamp of the next commit
+* @param {number} timestamp
+*/
+  setNextCommitTimestamp(timestamp: number): void;
+/**
+* Set the options of the next commit
+* @param {{ origin?: string, timestamp?: number, message?: string }} options
+*/
+  setNextCommitOptions(options: { origin?: string, timestamp?: number, message?: string }): void;
+/**
+* Clear the options of the next commit
+*/
+  clearNextCommitOptions(): void;
+/**
 * Get deep value of the document with container id
 * @returns {any}
 */