loro-crdt 0.13.1 → 0.14.1

package/dist/tests/event.test.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)("event", () => {
+    (0, vitest_1.it)("target", async () => {
+        const loro = new src_1.Loro();
+        let lastEvent;
+        loro.subscribe((event) => {
+            (0, vitest_1.expect)(event.by).toBe("local");
+            lastEvent = event;
+        });
+        const text = loro.getText("text");
+        const id = text.id;
+        text.insert(0, "123");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].target).toEqual(id);
+    });
+    (0, vitest_1.it)("path", async () => {
+        const loro = new src_1.Loro();
+        let lastEvent;
+        loro.subscribe((event) => {
+            lastEvent = event;
+        });
+        const map = loro.getMap("map");
+        const subMap = map.setContainer("sub", new src_1.LoroMap());
+        subMap.set("0", "1");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[1].path).toStrictEqual(["map", "sub"]);
+        const list = subMap.setContainer("list", new src_1.LoroList());
+        list.insert(0, "2");
+        const text = list.insertContainer(1, new src_1.LoroText());
+        loro.commit();
+        await oneMs();
+        text.insert(0, "3");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].path).toStrictEqual(["map", "sub", "list", 1]);
+    });
+    (0, vitest_1.it)("text diff", async () => {
+        const loro = new src_1.Loro();
+        let lastEvent;
+        loro.subscribe((event) => {
+            lastEvent = event;
+        });
+        const text = loro.getText("t");
+        text.insert(0, "3");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].diff).toStrictEqual({
+            type: "text",
+            diff: [{ insert: "3" }],
+        });
+        text.insert(1, "12");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].diff).toStrictEqual({
+            type: "text",
+            diff: [{ retain: 1 }, { insert: "12" }],
+        });
+    });
+    (0, vitest_1.it)("list diff", async () => {
+        const loro = new src_1.Loro();
+        let lastEvent;
+        loro.subscribe((event) => {
+            lastEvent = event;
+        });
+        const text = loro.getList("l");
+        text.insert(0, "3");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].diff).toStrictEqual({
+            type: "list",
+            diff: [{ insert: ["3"] }],
+        });
+        text.insert(1, "12");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].diff).toStrictEqual({
+            type: "list",
+            diff: [{ retain: 1 }, { insert: ["12"] }],
+        });
+    });
+    (0, vitest_1.it)("map diff", async () => {
+        const loro = new src_1.Loro();
+        let lastEvent;
+        loro.subscribe((event) => {
+            lastEvent = event;
+        });
+        const map = loro.getMap("m");
+        map.set("0", "3");
+        map.set("1", "2");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].diff).toStrictEqual({
+            type: "map",
+            updated: {
+                "0": "3",
+                "1": "2",
+            },
+        });
+        map.set("0", "0");
+        map.set("1", "1");
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].diff).toStrictEqual({
+            type: "map",
+            updated: {
+                "0": "0",
+                "1": "1",
+            },
+        });
+    });
+    (0, vitest_1.it)("tree", async () => {
+        const loro = new src_1.Loro();
+        let lastEvent;
+        loro.subscribe((event) => {
+            lastEvent = event;
+        });
+        const tree = loro.getTree("tree");
+        const id = tree.id;
+        tree.createNode();
+        loro.commit();
+        await oneMs();
+        (0, vitest_1.expect)(lastEvent?.events[0].target).toEqual(id);
+    });
+    (0, vitest_1.describe)("subscribe container events", () => {
+        (0, vitest_1.it)("text", async () => {
+            const loro = new src_1.Loro();
+            const text = loro.getText("text");
+            let ran = 0;
+            const sub = text.subscribe(loro, (event) => {
+                if (!ran) {
+                    (0, vitest_1.expect)(event.events[0].diff.diff).toStrictEqual([
+                        { insert: "123" },
+                    ]);
+                }
+                ran += 1;
+                for (const containerDiff of event.events) {
+                    (0, vitest_1.expect)(containerDiff.target).toBe(text.id);
+                }
+            });
+            text.insert(0, "123");
+            loro.commit();
+            await oneMs();
+            text.insert(1, "456");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(ran).toBeTruthy();
+            // subscribeOnce test
+            (0, vitest_1.expect)(text.toString()).toEqual("145623");
+            // unsubscribe
+            const oldRan = ran;
+            text.unsubscribe(loro, sub);
+            text.insert(0, "789");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(ran).toBe(oldRan);
+        });
+        (0, vitest_1.it)("map subscribe deep", async () => {
+            const loro = new src_1.Loro();
+            const map = loro.getMap("map");
+            let times = 0;
+            const sub = map.subscribe(loro, (event) => {
+                times += 1;
+            });
+            const subMap = map.setContainer("sub", new src_1.LoroMap());
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(1);
+            const text = subMap.setContainer("k", new src_1.LoroText());
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(2);
+            text.insert(0, "123");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(3);
+            // unsubscribe
+            loro.unsubscribe(sub);
+            text.insert(0, "123");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(3);
+        });
+        (0, vitest_1.it)("list subscribe deep", async () => {
+            const loro = new src_1.Loro();
+            const list = loro.getList("list");
+            let times = 0;
+            const sub = list.subscribe(loro, (_) => {
+                times += 1;
+            });
+            const text = list.insertContainer(0, new src_1.LoroText());
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(1);
+            text.insert(0, "123");
+            await oneMs();
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(2);
+            // unsubscribe
+            loro.unsubscribe(sub);
+            text.insert(0, "123");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(times).toBe(2);
+        });
+    });
+    (0, vitest_1.describe)("text event length should be utf16", () => {
+        (0, vitest_1.it)("test", async () => {
+            const loro = new src_1.Loro();
+            const text = loro.getText("text");
+            let string = "";
+            text.subscribe(loro, (event) => {
+                for (const containerDiff of event.events) {
+                    const diff = containerDiff.diff;
+                    (0, vitest_1.expect)(diff.type).toBe("text");
+                    if (diff.type === "text") {
+                        let newString = "";
+                        let pos = 0;
+                        for (const delta of diff.diff) {
+                            if (delta.retain != null) {
+                                newString += string.slice(pos, pos + delta.retain);
+                                pos += delta.retain;
+                            }
+                            else if (delta.insert != null) {
+                                newString += delta.insert;
+                            }
+                            else {
+                                pos += delta.delete;
+                            }
+                        }
+                        string = newString + string.slice(pos);
+                    }
+                }
+            });
+            text.insert(0, "你好");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(text.toString()).toBe(string);
+            text.insert(1, "世界");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(text.toString()).toBe(string);
+            text.insert(2, "👍");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(text.toString()).toBe(string);
+            text.insert(2, "♪(^∇^*)");
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(text.toString()).toBe(string);
+        });
+    });
+    (0, vitest_1.describe)("handler in event", () => {
+        (0, vitest_1.it)("test", async () => {
+            const loro = new src_1.Loro();
+            const list = loro.getList("list");
+            let first = true;
+            loro.subscribe((e) => {
+                if (first) {
+                    const diff = e.events[0].diff.diff;
+                    const text = diff[0].insert[0];
+                    text.insert(0, "abc");
+                    first = false;
+                }
+            });
+            list.insertContainer(0, new src_1.LoroText());
+            loro.commit();
+            await oneMs();
+            (0, vitest_1.expect)(loro.toJson().list[0]).toBe("abc");
+        });
+    });
+    (0, vitest_1.it)("diff can contain containers", async () => {
+        const doc = new src_1.Loro();
+        const list = doc.getList("list");
+        let ran = false;
+        doc.subscribe((event) => {
+            if (event.events[0].diff.type === "list") {
+                for (const item of event.events[0].diff.diff) {
+                    const t = item.insert[0];
+                    (0, vitest_1.expect)(t.toString()).toBe("Hello");
+                    (0, vitest_1.expect)(item.insert?.length).toBe(2);
+                    (0, vitest_1.expect)((0, src_1.getType)(item.insert[0])).toBe("Text");
+                    (0, vitest_1.expect)((0, src_1.getType)(item.insert[1])).toBe("Map");
+                }
+                ran = true;
+            }
+        });
+        list.insertContainer(0, new src_1.LoroMap());
+        const t = list.insertContainer(0, new src_1.LoroText());
+        t.insert(0, "He");
+        t.insert(2, "llo");
+        doc.commit();
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        (0, vitest_1.expect)(ran).toBeTruthy();
+    });
+    (0, vitest_1.it)("remote event", async () => {
+        const doc = new src_1.Loro();
+        const list = doc.getList("list");
+        list.insert(0, 123);
+        {
+            const doc2 = new src_1.Loro();
+            let triggered = false;
+            doc2.subscribe((event) => {
+                (0, vitest_1.expect)(event.by).toBe("import");
+                triggered = true;
+            });
+            doc2.import(doc.exportFrom());
+            await oneMs();
+            (0, vitest_1.expect)(triggered).toBeTruthy();
+        }
+        {
+            const doc2 = new src_1.Loro();
+            let triggered = false;
+            doc2.subscribe((event) => {
+                (0, vitest_1.expect)(event.by).toBe("import");
+                triggered = true;
+            });
+            doc2.import(doc.exportSnapshot());
+            await oneMs();
+            (0, vitest_1.expect)(triggered).toBeTruthy();
+        }
+    });
+    (0, vitest_1.it)("checkout event", async () => {
+        const doc = new src_1.Loro();
+        const list = doc.getList("list");
+        list.insert(0, 123);
+        doc.commit();
+        let triggered = false;
+        doc.subscribe((e) => {
+            (0, vitest_1.expect)(e.by).toBe("checkout");
+            triggered = true;
+        });
+        doc.checkout([]);
+        await oneMs();
+        (0, vitest_1.expect)(triggered).toBeTruthy();
+    });
+});
+function oneMs() {
+    return new Promise((r) => setTimeout(r));
+}

package/dist/tests/issue.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.it)("#211", () => {
+    const loro1 = new src_1.Loro();
+    loro1.setPeerId(0n);
+    const text1 = loro1.getText("text");
+    const loro2 = new src_1.Loro();
+    loro2.setPeerId(1n);
+    const text2 = loro2.getText("text");
+    console.log("[1] Insert T to #0");
+    text1.insert(0, "T");
+    loro1.commit();
+    show(text1, loro1, text2, loro2);
+    console.log("[2] Synchronize");
+    loro1.import(loro2.exportFrom(loro1.version()));
+    loro2.import(loro1.exportFrom(loro2.version()));
+    show(text1, loro1, text2, loro2);
+    const frontiers1After2 = loro1.frontiers();
+    const frontiers2After2 = loro2.frontiers();
+    console.log("[3] Append A to #0");
+    text1.insert(1, "A");
+    loro1.commit();
+    show(text1, loro1, text2, loro2);
+    console.log("[4] Append B to #1");
+    text2.insert(1, "B");
+    loro2.commit();
+    show(text1, loro1, text2, loro2);
+    console.log("[5] Play back to the frontiers after 2");
+    loro1.checkout(frontiers1After2);
+    loro2.checkout(frontiers2After2);
+    show(text1, loro1, text2, loro2);
+    console.log("[6] Check both to the latest");
+    loro1.checkoutToLatest();
+    loro2.checkoutToLatest();
+    show(text1, loro1, text2, loro2);
+    const frontiers1Before7 = loro1.frontiers();
+    const frontiers2Before7 = loro2.frontiers();
+    console.log("[7] Append B to #1");
+    text2.insert(2, "B");
+    loro2.commit();
+    show(text1, loro1, text2, loro2);
+    console.log("[8] Play back to the frontiers before 7");
+    console.log("----------------------------------------------------------");
+    loro1.checkout(frontiers1Before7);
+    console.log("----------------------------------------------------------");
+    loro2.checkout(frontiers2Before7);
+    show(text1, loro1, text2, loro2);
+});
+function show(text1, loro1, text2, loro2) {
+    console.log(`    #0 has content: ${JSON.stringify(text1.toString())}`);
+    console.log(`    #0 has frontiers: ${showFrontiers(loro1.frontiers())}`);
+    console.log(`    #1 has content: ${JSON.stringify(text2.toString())}`);
+    console.log(`    #1 has frontiers: ${showFrontiers(loro2.frontiers())}`);
+}
+function showFrontiers(frontiers) {
+    return frontiers.map((x) => `${x.peer}@${x.counter}`).join(";");
+}

package/dist/tests/misc.test.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+const vitest_2 = require("vitest");
+function assertEquals(a, b) {
+    (0, vitest_1.expect)(a).toStrictEqual(b);
+}
+(0, vitest_1.describe)("transaction", () => {
+    (0, vitest_1.it)("transaction", async () => {
+        const loro = new src_1.Loro();
+        const text = loro.getText("text");
+        let count = 0;
+        const sub = loro.subscribe(() => {
+            count += 1;
+            loro.unsubscribe(sub);
+        });
+        (0, vitest_1.expect)(count).toBe(0);
+        text.insert(0, "hello world");
+        (0, vitest_1.expect)(count).toBe(0);
+        text.insert(0, "hello world");
+        assertEquals(count, 0);
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 1);
+    });
+    (0, vitest_1.it)("transaction origin", async () => {
+        const loro = new src_1.Loro();
+        const text = loro.getText("text");
+        let count = 0;
+        const sub = loro.subscribe((event) => {
+            count += 1;
+            loro.unsubscribe(sub);
+            assertEquals(event.origin, "origin");
+        });
+        assertEquals(count, 0);
+        text.insert(0, "hello world");
+        assertEquals(count, 0);
+        text.insert(0, "hello world");
+        assertEquals(count, 0);
+        loro.commit("origin");
+        await one_ms();
+        assertEquals(count, 1);
+    });
+});
+(0, vitest_1.describe)("subscribe", () => {
+    (0, vitest_1.it)("subscribe_lock", async () => {
+        const loro = new src_1.Loro();
+        const text = loro.getText("text");
+        const list = loro.getList("list");
+        let count = 0;
+        let i = 1;
+        const sub = loro.subscribe(() => {
+            if (i > 0) {
+                list.insert(0, i);
+                loro.commit();
+                i--;
+            }
+            count += 1;
+        });
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 2);
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 3);
+        loro.unsubscribe(sub);
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 3);
+    });
+    (0, vitest_1.it)("subscribe_lock2", async () => {
+        const loro = new src_1.Loro();
+        const text = loro.getText("text");
+        let count = 0;
+        const sub = loro.subscribe(() => {
+            count += 1;
+            loro.unsubscribe(sub);
+        });
+        assertEquals(count, 0);
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 1);
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 1);
+    });
+    (0, vitest_1.it)("subscribe", async () => {
+        const loro = new src_1.Loro();
+        const text = loro.getText("text");
+        let count = 0;
+        const sub = loro.subscribe(() => {
+            count += 1;
+        });
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 1);
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 2);
+        loro.unsubscribe(sub);
+        text.insert(0, "hello world");
+        loro.commit();
+        await one_ms();
+        assertEquals(count, 2);
+    });
+});
+(0, vitest_1.describe)("sync", () => {
+    (0, vitest_1.it)("two insert at beginning", async () => {
+        const a = new src_1.Loro();
+        const b = new src_1.Loro();
+        let a_version = undefined;
+        let b_version = undefined;
+        a.subscribe((e) => {
+            if (e.by == "local") {
+                const exported = a.exportFrom(a_version);
+                b.import(exported);
+                a_version = a.version();
+            }
+        });
+        b.subscribe((e) => {
+            if (e.by == "local") {
+                const exported = b.exportFrom(b_version);
+                a.import(exported);
+                b_version = b.version();
+            }
+        });
+        const aText = a.getText("text");
+        const bText = b.getText("text");
+        aText.insert(0, "abc");
+        a.commit();
+        await one_ms();
+        assertEquals(aText.toString(), bText.toString());
+    });
+    (0, vitest_1.it)("sync", () => {
+        const loro = new src_1.Loro();
+        const text = loro.getText("text");
+        text.insert(0, "hello world");
+        const loro_bk = new src_1.Loro();
+        loro_bk.import(loro.exportFrom(undefined));
+        assertEquals(loro_bk.toJson(), loro.toJson());
+        const text_bk = loro_bk.getText("text");
+        assertEquals(text_bk.toString(), "hello world");
+        text_bk.insert(0, "a ");
+        loro.import(loro_bk.exportFrom(undefined));
+        assertEquals(text.toString(), "a hello world");
+        const map = loro.getMap("map");
+        map.set("key", "value");
+    });
+});
+(0, vitest_1.describe)("wasm", () => {
+    const loro = new src_1.Loro();
+    const a = loro.getText("ha");
+    a.insert(0, "hello world");
+    a.delete(6, 5);
+    a.insert(6, "everyone");
+    loro.commit();
+    const b = loro.getMap("ha");
+    b.set("ab", 123);
+    loro.commit();
+    const bText = b.setContainer("hh", new src_1.LoroText());
+    loro.commit();
+    (0, vitest_1.it)("map get", () => {
+        assertEquals(b.get("ab"), 123);
+    });
+    (0, vitest_1.it)("getValueDeep", () => {
+        bText.insert(0, "hello world Text");
+        assertEquals(b.toJson(), { ab: 123, hh: "hello world Text" });
+    });
+    (0, vitest_1.it)("get container by id", () => {
+        const id = b.id;
+        const b2 = loro.getContainerById(id);
+        assertEquals(b2.toJson(), b.toJson());
+        assertEquals(b2.id, id);
+        b2.set("0", 12);
+        assertEquals(b2.toJson(), b.toJson());
+    });
+});
+(0, vitest_1.describe)("type", () => {
+    (0, vitest_1.it)("test map type", () => {
+        const loro = new src_1.Loro();
+        const map = loro.getTypedMap("map");
+        const v = map.getTyped(loro, "name");
+        (0, vitest_2.expectTypeOf)(v).toEqualTypeOf();
+    });
+    (0, vitest_1.it)("test recursive map type", () => {
+        const loro = new src_1.Loro();
+        const map = loro.getTypedMap("map");
+        map.setContainer("map", new src_1.LoroMap());
+        const subMap = map.getTyped(loro, "map");
+        const name = subMap.getTyped(loro, "name");
+        (0, vitest_2.expectTypeOf)(name).toEqualTypeOf();
+    });
+    (0, vitest_1.it)("works for list type", () => {
+        const loro = new src_1.Loro();
+        const list = loro.getTypedList("list");
+        list.insertTyped(0, "123");
+        list.insertTyped(1, 123);
+        const v0 = list.getTyped(loro, 0);
+        (0, vitest_2.expectTypeOf)(v0).toEqualTypeOf();
+        const v1 = list.getTyped(loro, 1);
+        (0, vitest_2.expectTypeOf)(v1).toEqualTypeOf();
+    });
+    (0, vitest_1.it)("test binary type", () => {
+        // const loro = new Loro<{ list: LoroList<[string, number]> }>();
+        // const list = loro.getTypedList("list");
+        // console.dir((list as any).__proto__);
+        // list.insertTyped(0, new Uint8Array(10));
+        // const v0 = list.getTyped(loro, 0);
+        // expectTypeOf(v0).toEqualTypeOf<Uint8Array>();
+    });
+});
+(0, vitest_1.describe)("tree", () => {
+    const loro = new src_1.Loro();
+    const tree = loro.getTree("root");
+    (0, vitest_1.it)("create", () => {
+        const root = tree.createNode();
+        const child = root.createNode();
+        assertEquals(child.parent().id, root.id);
+    });
+    (0, vitest_1.it)("move", () => {
+        const root = tree.createNode();
+        const child = root.createNode();
+        const child2 = root.createNode();
+        assertEquals(child2.parent().id, root.id);
+        child2.moveTo(child);
+        assertEquals(child2.parent().id, child.id);
+        assertEquals(child.children()[0].id, child2.id);
+    });
+    (0, vitest_1.it)("meta", () => {
+        const root = tree.createNode();
+        root.data.set("a", 123);
+        assertEquals(root.data.get("a"), 123);
+    });
+});
+function one_ms() {
+    return new Promise((resolve) => setTimeout(resolve, 1));
+}