loro-crdt 0.13.1 → 0.14.1

package/dist/tests/richtext.test.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)("richtext", () => {
+    (0, vitest_1.it)("mark", () => {
+        const doc = new src_1.Loro();
+        doc.configTextStyle({
+            bold: { expand: "after" },
+            link: { expand: "before" },
+        });
+        const text = doc.getText("text");
+        text.insert(0, "Hello World!");
+        text.mark({ start: 0, end: 5 }, "bold", true);
+        (0, vitest_1.expect)(text.toDelta()).toStrictEqual([
+            {
+                insert: "Hello",
+                attributes: {
+                    bold: true,
+                },
+            },
+            {
+                insert: " World!",
+            },
+        ]);
+    });
+    (0, vitest_1.it)("insert after emoji", () => {
+        const doc = new src_1.Loro();
+        const text = doc.getText("text");
+        text.insert(0, "👨‍👩‍👦");
+        text.insert(8, "a");
+        (0, vitest_1.expect)(text.toString()).toBe("👨‍👩‍👦a");
+    });
+    (0, vitest_1.it)("emit event correctly", async () => {
+        const doc = new src_1.Loro();
+        const text = doc.getText("text");
+        let triggered = false;
+        text.subscribe(doc, (e) => {
+            for (const event of e.events) {
+                if (event.diff.type == "text") {
+                    (0, vitest_1.expect)(event.diff.diff).toStrictEqual([
+                        {
+                            insert: "Hello",
+                            attributes: {
+                                bold: true,
+                            },
+                        },
+                        {
+                            insert: " World!",
+                        },
+                    ]);
+                    triggered = true;
+                }
+            }
+        });
+        text.insert(0, "Hello World!");
+        text.mark({ start: 0, end: 5 }, "bold", true);
+        doc.commit();
+        await new Promise((r) => setTimeout(r, 1));
+        (0, vitest_1.expect)(triggered).toBeTruthy();
+    });
+    (0, vitest_1.it)("emit event from merging doc correctly", async () => {
+        const doc = new src_1.Loro();
+        const text = doc.getText("text");
+        let called = false;
+        text.subscribe(doc, (event) => {
+            if (event.events[0].diff.type == "text") {
+                called = true;
+                (0, vitest_1.expect)(event.events[0].diff.diff).toStrictEqual([
+                    {
+                        insert: "Hello",
+                        attributes: {
+                            bold: true,
+                        },
+                    },
+                    {
+                        insert: " World!",
+                    },
+                ]);
+            }
+        });
+        const docB = new src_1.Loro();
+        const textB = docB.getText("text");
+        textB.insert(0, "Hello World!");
+        textB.mark({ start: 0, end: 5 }, "bold", true);
+        doc.import(docB.exportFrom());
+        await new Promise((r) => setTimeout(r, 1));
+        (0, vitest_1.expect)(called).toBeTruthy();
+    });
+    (0, vitest_1.it)("Delete emoji", async () => {
+        const doc = new src_1.Loro();
+        const text = doc.getText("text");
+        text.insert(0, "012345👨‍👩‍👦6789");
+        doc.commit();
+        text.mark({ start: 0, end: 18 }, "bold", true);
+        doc.commit();
+        (0, vitest_1.expect)(text.toDelta()).toStrictEqual([
+            {
+                insert: "012345👨‍👩‍👦6789",
+                attributes: { bold: true },
+            },
+        ]);
+        text.delete(6, 8);
+        doc.commit();
+        (0, vitest_1.expect)(text.toDelta()).toStrictEqual([
+            {
+                insert: "0123456789",
+                attributes: { bold: true },
+            },
+        ]);
+    });
+    (0, vitest_1.it)("apply delta", async () => {
+        const doc1 = new src_1.Loro();
+        doc1.configTextStyle({
+            link: { expand: "none" },
+            bold: { expand: "after" },
+        });
+        const text1 = doc1.getText("text");
+        const doc2 = new src_1.Loro();
+        doc2.configTextStyle({
+            link: { expand: "none" },
+            bold: { expand: "after" },
+        });
+        const text2 = doc2.getText("text");
+        text1.subscribe(doc1, (event) => {
+            for (const containerDiff of event.events) {
+                const e = containerDiff.diff;
+                text2.applyDelta(e.diff);
+            }
+        });
+        text1.insert(0, "foo");
+        text1.mark({ start: 0, end: 3 }, "link", true);
+        doc1.commit();
+        await new Promise((r) => setTimeout(r, 1));
+        (0, vitest_1.expect)(text2.toDelta()).toStrictEqual(text1.toDelta());
+        text1.insert(3, "baz");
+        doc1.commit();
+        await new Promise((r) => setTimeout(r, 1));
+        (0, vitest_1.expect)(text2.toDelta()).toStrictEqual([
+            { insert: "foo", attributes: { link: true } },
+            { insert: "baz" },
+        ]);
+        (0, vitest_1.expect)(text2.toDelta()).toStrictEqual(text1.toDelta());
+        text1.mark({ start: 2, end: 5 }, "bold", true);
+        doc1.commit();
+        await new Promise((r) => setTimeout(r, 1));
+        (0, vitest_1.expect)(text2.toDelta()).toStrictEqual(text1.toDelta());
+    });
+    (0, vitest_1.it)("custom richtext type", async () => {
+        const doc = new src_1.Loro();
+        doc.configTextStyle({
+            myStyle: {
+                expand: "none",
+            },
+        });
+        const text = doc.getText("text");
+        text.insert(0, "foo");
+        text.mark({ start: 0, end: 3 }, "myStyle", 123);
+        (0, vitest_1.expect)(text.toDelta()).toStrictEqual([
+            { insert: "foo", attributes: { myStyle: 123 } },
+        ]);
+        (0, vitest_1.expect)(() => {
+            text.mark({ start: 0, end: 3 }, "unknownStyle", 2);
+        }).toThrowError();
+        (0, vitest_1.expect)(() => {
+            // default style config should be overwritten
+            text.mark({ start: 0, end: 3 }, "bold", 2);
+        }).toThrowError();
+    });
+    (0, vitest_1.it)("allow overlapped styles", () => {
+        const doc = new src_1.Loro();
+        doc.configTextStyle({
+            comment: { expand: "none" },
+        });
+        const text = doc.getText("text");
+        text.insert(0, "The fox jumped.");
+        text.mark({ start: 0, end: 7 }, "comment:alice", "Hi");
+        text.mark({ start: 4, end: 14 }, "comment:bob", "Jump");
+        (0, vitest_1.expect)(text.toDelta()).toStrictEqual([
+            {
+                insert: "The ",
+                attributes: { "comment:alice": "Hi" },
+            },
+            {
+                insert: "fox",
+                attributes: { "comment:alice": "Hi", "comment:bob": "Jump" },
+            },
+            {
+                insert: " jumped",
+                attributes: { "comment:bob": "Jump" },
+            },
+            {
+                insert: ".",
+            },
+        ]);
+    });
+});

package/dist/tests/type.test.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../src");
+const vitest_1 = require("vitest");
+(0, vitest_1.test)("Container should not match Value", () => {
+    const list = new src_1.LoroList();
+    (0, vitest_1.expectTypeOf)(list).not.toMatchTypeOf();
+});
+(0, vitest_1.test)("A non-numeric string is not a valid peer id", () => {
+    (0, vitest_1.expectTypeOf)("123").toMatchTypeOf();
+    (0, vitest_1.expectTypeOf)("a123").not.toMatchTypeOf();
+});
+(0, vitest_1.test)("Expect container type", () => {
+    const list = new src_1.LoroList();
+    (0, vitest_1.expectTypeOf)(list.kind()).toMatchTypeOf();
+    const map = new src_1.LoroMap();
+    (0, vitest_1.expectTypeOf)(map.kind()).toMatchTypeOf();
+    const text = new src_1.LoroText();
+    (0, vitest_1.expectTypeOf)(text.kind()).toMatchTypeOf();
+    const tree = new src_1.LoroTree();
+    (0, vitest_1.expectTypeOf)(tree.kind()).toMatchTypeOf();
+});

package/dist/tests/version.test.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)("Frontiers", () => {
+    (0, vitest_1.it)("two clients", () => {
+        const doc = new src_1.Loro();
+        doc.setPeerId(0);
+        const text = doc.getText("text");
+        text.insert(0, "0");
+        doc.commit();
+        const v0 = doc.frontiers();
+        const docB = new src_1.Loro();
+        docB.setPeerId(1);
+        docB.import(doc.exportFrom());
+        (0, vitest_1.expect)(docB.cmpWithFrontiers(v0)).toBe(0);
+        text.insert(1, "0");
+        doc.commit();
+        (0, vitest_1.expect)(docB.cmpWithFrontiers(doc.frontiers())).toBe(-1);
+        const textB = docB.getText("text");
+        textB.insert(0, "0");
+        docB.commit();
+        (0, vitest_1.expect)(docB.cmpWithFrontiers(doc.frontiers())).toBe(-1);
+        docB.import(doc.exportFrom());
+        (0, vitest_1.expect)(docB.cmpWithFrontiers(doc.frontiers())).toBe(1);
+        doc.import(docB.exportFrom());
+        (0, vitest_1.expect)(docB.cmpWithFrontiers(doc.frontiers())).toBe(0);
+    });
+    (0, vitest_1.it)("cmp frontiers", () => {
+        const doc1 = new src_1.Loro();
+        doc1.setPeerId(1);
+        const doc2 = new src_1.Loro();
+        doc2.setPeerId(2n);
+        doc1.getText("text").insert(0, "01234");
+        doc2.import(doc1.exportFrom());
+        doc2.getText("text").insert(0, "56789");
+        doc1.import(doc2.exportFrom());
+        doc1.getText("text").insert(0, "01234");
+        doc1.commit();
+        (0, vitest_1.expect)(() => {
+            doc1.cmpFrontiers([{ peer: "1", counter: 1 }], [
+                {
+                    peer: "2",
+                    counter: 10,
+                },
+            ]);
+        }).toThrow();
+        (0, vitest_1.expect)(doc1.cmpFrontiers([], [{ peer: "1", counter: 1 }])).toBe(-1);
+        (0, vitest_1.expect)(doc1.cmpFrontiers([], [])).toBe(0);
+        (0, vitest_1.expect)(doc1.cmpFrontiers([{ peer: "1", counter: 4 }], [
+            {
+                peer: "2",
+                counter: 3,
+            },
+        ])).toBe(-1);
+        (0, vitest_1.expect)(doc1.cmpFrontiers([{ peer: "1", counter: 5 }], [
+            {
+                peer: "2",
+                counter: 3,
+            },
+        ])).toBe(1);
+    });
+});
+(0, vitest_1.it)("peer id repr should be consistent", () => {
+    const doc = new src_1.Loro();
+    const id = doc.peerIdStr;
+    doc.getText("text").insert(0, "hello");
+    doc.commit();
+    const f = doc.frontiers();
+    (0, vitest_1.expect)(f[0].peer).toBe(id);
+    const child = new src_1.LoroMap();
+    const map = doc.getList("list").insertContainer(0, child);
+    const mapId = map.id;
+    const peerIdInContainerId = mapId.split(":")[1].split("@")[1];
+    (0, vitest_1.expect)(peerIdInContainerId).toBe(id);
+    doc.commit();
+    (0, vitest_1.expect)(doc.version().get(id)).toBe(6);
+    (0, vitest_1.expect)(doc.version().toJSON().get(id)).toBe(6);
+    const m = doc.getMap(mapId);
+    m.set("0", 1);
+    (0, vitest_1.expect)(map.get("0")).toBe(1);
+});
+(0, vitest_1.describe)("Version", () => {
+    const a = new src_1.Loro();
+    a.setPeerId(0n);
+    const b = new src_1.Loro();
+    b.setPeerId(1n);
+    a.getText("text").insert(0, "ha");
+    b.getText("text").insert(0, "yo");
+    a.import(b.exportFrom());
+    a.getText("text").insert(0, "k");
+    a.commit();
+    (0, vitest_1.it)("version vector to frontiers", () => {
+        {
+            const vv = new Map();
+            vv.set("0", 3);
+            vv.set("1", 2);
+            (0, vitest_1.expect)(a.version().toJSON()).toStrictEqual(vv);
+            (0, vitest_1.expect)(a.version().toJSON()).toStrictEqual(vv);
+            (0, vitest_1.expect)(a.vvToFrontiers(new src_1.VersionVector(vv))).toStrictEqual(a.frontiers());
+            const v = a.version();
+            const temp = a.vvToFrontiers(v);
+            (0, vitest_1.expect)(temp).toStrictEqual(a.frontiers());
+            (0, vitest_1.expect)(a.frontiers()).toStrictEqual([
+                { peer: "0", counter: 2 },
+            ]);
+        }
+    });
+    (0, vitest_1.it)("get changes", () => {
+        const changes = a.getAllChanges();
+        (0, vitest_1.expect)(typeof changes.get("0")?.[0].peer == "string").toBeTruthy();
+        (0, vitest_1.expect)(changes.size).toBe(2);
+        (0, vitest_1.expect)(changes.get("0")?.length).toBe(2);
+        (0, vitest_1.expect)(changes.get("0")?.[0].length).toBe(2);
+        (0, vitest_1.expect)(changes.get("0")?.[1].lamport).toBe(2);
+        (0, vitest_1.expect)(changes.get("0")?.[1].deps).toStrictEqual([
+            { peer: "0", counter: 1 },
+            { peer: "1", counter: 1 },
+        ]);
+        (0, vitest_1.expect)(changes.get("1")?.length).toBe(1);
+    });
+    (0, vitest_1.it)("get ops inside changes", () => {
+        const change = a.getOpsInChange({ peer: "0", counter: 2 });
+        (0, vitest_1.expect)(change.length).toBe(1);
+    });
+});
+(0, vitest_1.it)("get import blob metadata", () => {
+    const doc0 = new src_1.Loro();
+    doc0.setPeerId(0n);
+    const text = doc0.getText("text");
+    text.insert(0, "0");
+    doc0.commit();
+    {
+        const bytes = doc0.exportFrom();
+        const meta = (0, src_1.decodeImportBlobMeta)(bytes);
+        (0, vitest_1.expect)(meta.changeNum).toBe(1);
+        (0, vitest_1.expect)(meta.partialStartVersionVector.get("0")).toBeFalsy();
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("0")).toBe(1);
+        (0, vitest_1.expect)(meta.startTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.endTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.isSnapshot).toBeFalsy();
+        (0, vitest_1.expect)(meta.startFrontiers.length).toBe(0);
+    }
+    const doc1 = new src_1.Loro();
+    doc1.setPeerId(1);
+    doc1.getText("text").insert(0, "123");
+    doc1.import(doc0.exportFrom());
+    {
+        const bytes = doc1.exportFrom();
+        const meta = (0, src_1.decodeImportBlobMeta)(bytes);
+        (0, vitest_1.expect)(meta.changeNum).toBe(2);
+        (0, vitest_1.expect)(meta.partialStartVersionVector.get("0")).toBeFalsy();
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("0")).toBe(1);
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("1")).toBe(3);
+        (0, vitest_1.expect)(meta.startTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.endTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.isSnapshot).toBeFalsy();
+        (0, vitest_1.expect)(meta.startFrontiers.length).toBe(0);
+    }
+    {
+        const bytes = doc1.exportSnapshot();
+        const meta = (0, src_1.decodeImportBlobMeta)(bytes);
+        (0, vitest_1.expect)(meta.changeNum).toBe(2);
+        (0, vitest_1.expect)(meta.partialStartVersionVector.get("0")).toBeFalsy();
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("0")).toBe(1);
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("1")).toBe(3);
+        (0, vitest_1.expect)(meta.startTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.endTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.isSnapshot).toBeTruthy();
+        (0, vitest_1.expect)(meta.startFrontiers.length).toBe(0);
+    }
+    {
+        const bytes = doc1.exportFrom(doc0.oplogVersion());
+        const meta = (0, src_1.decodeImportBlobMeta)(bytes);
+        (0, vitest_1.expect)(meta.changeNum).toBe(1);
+        (0, vitest_1.expect)(meta.partialStartVersionVector.get("0")).toBeUndefined();
+        (0, vitest_1.expect)(meta.partialStartVersionVector.get("1")).toBeFalsy();
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("0")).toBeUndefined();
+        (0, vitest_1.expect)(meta.partialEndVersionVector.get("1")).toBe(3);
+        (0, vitest_1.expect)(meta.startTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.endTimestamp).toBe(0);
+        (0, vitest_1.expect)(meta.isSnapshot).toBeFalsy();
+        (0, vitest_1.expect)(meta.startFrontiers).toStrictEqual([{ peer: "0", counter: 0 }]);
+    }
+});

package/dist/vite.config.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="vitest" />
+const vite_plugin_wasm_1 = __importDefault(require("vite-plugin-wasm"));
+const vite_1 = require("vite");
+exports.default = (0, vite_1.defineConfig)({
+    plugins: [(0, vite_plugin_wasm_1.default)()],
+    // test: {
+    //   reporters:['hanging-process']
+    // },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loro-crdt",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "description": "Loro CRDTs is a high-performance CRDT framework that makes your app state synchronized, collaborative and maintainable effortlessly.",
   "keywords": [
     "crdt",
@@ -17,7 +17,7 @@
   "homepage": "https://loro.dev",
   "license": "MIT",
   "dependencies": {
-    "loro-wasm": "0.13.1"
+    "loro-wasm": "0.14.1"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^15.0.1",
@@ -37,7 +37,7 @@
   "scripts": {
     "build": "rollup -c",
     "watch": "rollup -c -w",
-    "test": "vitest run --typecheck",
+    "test": "vitest run && npx tsc --noEmit",
     "prepublish": "pnpm run build"
   }
 }