loro-crdt 1.4.5 → 1.5.0

package/web/loro_wasm.js

@@ -613,6 +613,52 @@ export class AwarenessWasm {
     }
 }
 
+const ChangeModifierFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_changemodifier_free(ptr >>> 0));
+/**
+*/
+export class ChangeModifier {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ChangeModifier.prototype);
+        obj.__wbg_ptr = ptr;
+        ChangeModifierFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChangeModifierFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_changemodifier_free(ptr);
+    }
+    /**
+    * @param {string} message
+    * @returns {ChangeModifier}
+    */
+    setMessage(message) {
+        const ptr0 = passStringToWasm0(message, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.changemodifier_setMessage(this.__wbg_ptr, ptr0, len0);
+        return ChangeModifier.__wrap(ret);
+    }
+    /**
+    * @param {number} timestamp
+    * @returns {ChangeModifier}
+    */
+    setTimestamp(timestamp) {
+        const ret = wasm.changemodifier_setTimestamp(this.__wbg_ptr, timestamp);
+        return ChangeModifier.__wrap(ret);
+    }
+}
+
 const CursorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_cursor_free(ptr >>> 0));
@@ -745,6 +791,161 @@ export class Cursor {
     }
 }
 
+const EphemeralStoreWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ephemeralstorewasm_free(ptr >>> 0));
+/**
+*/
+export class EphemeralStoreWasm {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EphemeralStoreWasmFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ephemeralstorewasm_free(ptr);
+    }
+    /**
+    * Creates a new `EphemeralStore` instance.
+    *
+    * The `timeout` parameter specifies the duration in milliseconds.
+    * A state of a peer is considered outdated, if the last update of the state of the peer
+    * is older than the `timeout`.
+    * @param {number} timeout
+    */
+    constructor(timeout) {
+        const ret = wasm.ephemeralstorewasm_new(timeout);
+        this.__wbg_ptr = ret >>> 0;
+        return this;
+    }
+    /**
+    * @param {string} key
+    * @param {any} value
+    */
+    set(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ephemeralstorewasm_set(this.__wbg_ptr, ptr0, len0, addHeapObject(value));
+    }
+    /**
+    * @param {string} key
+    */
+    delete(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ephemeralstorewasm_delete(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    * @param {string} key
+    * @returns {any}
+    */
+    get(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ephemeralstorewasm_get(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {any}
+    */
+    getAllStates() {
+        const ret = wasm.ephemeralstorewasm_getAllStates(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribeLocalUpdates(f) {
+        const ret = wasm.ephemeralstorewasm_subscribeLocalUpdates(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
+    /**
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribe(f) {
+        const ret = wasm.ephemeralstorewasm_subscribe(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
+    /**
+    * @param {string} key
+    * @returns {Uint8Array}
+    */
+    encode(key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ephemeralstorewasm_encode(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    encodeAll() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ephemeralstorewasm_encodeAll(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {Uint8Array} data
+    */
+    apply(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export_0);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ephemeralstorewasm_apply(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+    */
+    removeOutdated() {
+        wasm.ephemeralstorewasm_removeOutdated(this.__wbg_ptr);
+    }
+    /**
+    * If the state is empty.
+    * @returns {boolean}
+    */
+    isEmpty() {
+        const ret = wasm.ephemeralstorewasm_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * @returns {(string)[]}
+    */
+    keys() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ephemeralstorewasm_keys(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_5(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
 const LoroCounterFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lorocounter_free(ptr >>> 0));
@@ -2797,6 +2998,61 @@ export class LoroDoc {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+    * Get the pending operations from the current transaction in JSON format
+    *
+    * This method returns a JSON representation of operations that have been applied
+    * but not yet committed in the current transaction.
+    *
+    * It will use the same data format as `doc.exportJsonUpdates()`
+    *
+    * @example
+    * ```ts
+    * const doc = new LoroDoc();
+    * const text = doc.getText("text");
+    * text.insert(0, "Hello");
+    * // Get pending ops before commit
+    * const pendingOps = doc.getPendingOpsFromCurrentTxnAsJson();
+    * doc.commit();
+    * const emptyOps = doc.getPendingOpsFromCurrentTxnAsJson(); // this is undefined
+    * ```
+    * @returns {JsonSchema | undefined}
+    */
+    getUncommittedOpsAsJson() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.lorodoc_getUncommittedOpsAsJson(retptr, this.__wbg_ptr);
+            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 {Function} f
+    * @returns {any}
+    */
+    subscribeFirstCommitFromPeer(f) {
+        const ret = wasm.lorodoc_subscribeFirstCommitFromPeer(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
+    /**
+    * Subscribe to the pre-commit event.
+    *
+    * The callback will be called when the changes are committed but not yet applied to the OpLog.
+    * You can modify the commit message and timestamp in the callback by `ChangeModifier`.
+    * @param {Function} f
+    * @returns {any}
+    */
+    subscribePreCommit(f) {
+        const ret = wasm.lorodoc_subscribePreCommit(this.__wbg_ptr, addHeapObject(f));
+        return takeObject(ret);
+    }
 }
 
 const LoroListFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -4627,8 +4883,6 @@ export class LoroText {
     *
     * You can use it to create a highlight, make a range of text bold, or add a link to a range of text.
     *
-    * Note: this is not suitable for unmergeable annotations like comments.
-    *
     * @example
     * ```ts
     * import { LoroDoc } from "loro-crdt";
@@ -6176,10 +6430,6 @@ function __wbg_get_imports() {
         const ret = LoroCounter.__wrap(arg0);
         return addHeapObject(ret);
     };
-    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);
         return addHeapObject(ret);
@@ -6188,26 +6438,34 @@ function __wbg_get_imports() {
         const ret = LoroMap.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorotext_new = function(arg0) {
-        const ret = LoroText.__wrap(arg0);
+    imports.wbg.__wbg_lorotreenode_new = function(arg0) {
+        const ret = LoroTreeNode.__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_lorotext_new = function(arg0) {
+        const ret = LoroText.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_loromovablelist_new = function(arg0) {
         const ret = LoroMovableList.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_lorolist_new = function(arg0) {
-        const ret = LoroList.__wrap(arg0);
+    imports.wbg.__wbg_lorotree_new = function(arg0) {
+        const ret = LoroTree.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_versionvector_new = function(arg0) {
         const ret = VersionVector.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_changemodifier_new = function(arg0) {
+        const ret = ChangeModifier.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_is_function = function(arg0) {
         const ret = typeof(getObject(arg0)) === 'function';
         return ret;
@@ -6396,7 +6654,7 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export_5(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_now_cd30a09c9b727b65 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
+    imports.wbg.__wbg_now_761faa1e2f3f9d93 = typeof Date.now == 'function' ? Date.now : notDefined('Date.now');
     imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -6421,12 +6679,12 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
-        getObject(arg0).getRandomValues(getObject(arg1));
-    }, arguments) };
     imports.wbg.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).randomFillSync(takeObject(arg1));
     }, arguments) };
+    imports.wbg.__wbg_getRandomValues_3aa56aa6edec874c = function() { return handleError(function (arg0, arg1) {
+        getObject(arg0).getRandomValues(getObject(arg1));
+    }, arguments) };
     imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
         const ret = self.self;
         return addHeapObject(ret);
@@ -6659,12 +6917,12 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper482 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_60);
+    imports.wbg.__wbindgen_closure_wrapper487 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_60);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper485 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 10, __wbg_adapter_63);
+    imports.wbg.__wbindgen_closure_wrapper489 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 8, __wbg_adapter_63);
         return addHeapObject(ret);
     };
 

package/web/loro_wasm_bg.wasm.d.ts

@@ -27,6 +27,20 @@ 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 __wbg_ephemeralstorewasm_free(a: number): void;
+export function ephemeralstorewasm_new(a: number): number;
+export function ephemeralstorewasm_set(a: number, b: number, c: number, d: number): void;
+export function ephemeralstorewasm_delete(a: number, b: number, c: number): void;
+export function ephemeralstorewasm_get(a: number, b: number, c: number): number;
+export function ephemeralstorewasm_getAllStates(a: number): number;
+export function ephemeralstorewasm_subscribeLocalUpdates(a: number, b: number): number;
+export function ephemeralstorewasm_subscribe(a: number, b: number): number;
+export function ephemeralstorewasm_encode(a: number, b: number, c: number, d: number): void;
+export function ephemeralstorewasm_encodeAll(a: number, b: number): void;
+export function ephemeralstorewasm_apply(a: number, b: number, c: number): void;
+export function ephemeralstorewasm_removeOutdated(a: number): void;
+export function ephemeralstorewasm_isEmpty(a: number): number;
+export function ephemeralstorewasm_keys(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;
@@ -107,6 +121,9 @@ export function lorodoc_getChangedContainersIn(a: number, b: number, c: number,
 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, g: number): void;
+export function lorodoc_getUncommittedOpsAsJson(a: number, b: number): void;
+export function lorodoc_subscribeFirstCommitFromPeer(a: number, b: number): number;
+export function lorodoc_subscribePreCommit(a: number, b: number): number;
 export function __wbg_lorotext_free(a: number): void;
 export function lorotext_new(): number;
 export function lorotext_kind(a: number): number;
@@ -278,6 +295,9 @@ export function versionvector_setLast(a: number, b: number, c: number): void;
 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_changemodifier_free(a: number): void;
+export function changemodifier_setMessage(a: number, b: number, c: number): number;
+export function changemodifier_setTimestamp(a: number, b: number): number;
 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;