loro-crdt 0.2.8-alpha-1 → 0.4.0

package/src/index.ts

@@ -1,40 +1,14 @@
-export {
-  LoroList,
-  LoroMap,
-  LoroText,
-  PrelimList,
-  PrelimMap,
-  PrelimText,
-  setPanicHook,
-  Transaction,
-} from "loro-wasm";
-import { PrelimMap } from "loro-wasm";
-import { PrelimText } from "loro-wasm";
-import { PrelimList } from "loro-wasm";
-import {
-  ContainerID,
-  Loro,
-  LoroList,
-  LoroMap,
-  LoroText,
-  Transaction,
-} from "loro-wasm";
+export * from "loro-wasm";
+import { Delta } from "loro-wasm";
+import { PrelimText,PrelimList,PrelimMap } from "loro-wasm";
+import { ContainerID, Loro, LoroList, LoroMap, LoroText , LoroTree, TreeID} from "loro-wasm";
 
-export type { ContainerID, ContainerType } from "loro-wasm";
-
-Loro.prototype.transact = function (cb, origin) {
-  this.__raw__transactionWithOrigin(origin, (txn: Transaction) => {
-    try {
-      cb(txn);
-    } finally {
-      txn.commit();
-      txn.free();
-    }
-  });
+Loro.prototype.getTypedMap = function (...args) {
+  return this.getMap(...args);
+};
+Loro.prototype.getTypedList = function (...args) {
+  return this.getList(...args);
 };
-
-Loro.prototype.getTypedMap = Loro.prototype.getMap;
-Loro.prototype.getTypedList = Loro.prototype.getList;
 LoroList.prototype.getTyped = function (loro, index) {
   const value = this.get(index);
   if (typeof value === "string" && isContainerId(value)) {
@@ -43,7 +17,9 @@ LoroList.prototype.getTyped = function (loro, index) {
     return value;
   }
 };
-LoroList.prototype.insertTyped = LoroList.prototype.insert;
+LoroList.prototype.insertTyped = function (...args) {
+  return this.insert(...args);
+};
 LoroMap.prototype.getTyped = function (loro, key) {
   const value = this.get(key);
   if (typeof value === "string" && isContainerId(value)) {
@@ -52,77 +28,57 @@ LoroMap.prototype.getTyped = function (loro, key) {
     return value;
   }
 };
-LoroMap.prototype.setTyped = LoroMap.prototype.set;
-
-LoroText.prototype.insert = function (txn, pos, text) {
-  if (txn instanceof Loro) {
-    this.__loro_insert(txn, pos, text);
-  } else {
-    this.__txn_insert(txn, pos, text);
-  }
-};
-
-LoroText.prototype.delete = function (txn, pos, len) {
-  if (txn instanceof Loro) {
-    this.__loro_delete(txn, pos, len);
-  } else {
-    this.__txn_delete(txn, pos, len);
-  }
-};
-
-LoroList.prototype.insert = function (txn, pos, len) {
-  if (txn instanceof Loro) {
-    this.__loro_insert(txn, pos, len);
-  } else {
-    this.__txn_insert(txn, pos, len);
-  }
-};
-
-LoroList.prototype.delete = function (txn, pos, len) {
-  if (txn instanceof Loro) {
-    this.__loro_delete(txn, pos, len);
-  } else {
-    this.__txn_delete(txn, pos, len);
-  }
-};
-
-LoroMap.prototype.set = function (txn, key, value) {
-  if (txn instanceof Loro) {
-    this.__loro_insert(txn, key, value);
-  } else {
-    this.__txn_insert(txn, key, value);
-  }
-};
-
-LoroMap.prototype.delete = function (txn, key) {
-  if (txn instanceof Loro) {
-    this.__loro_delete(txn, key);
-  } else {
-    this.__txn_delete(txn, key);
-  }
+LoroMap.prototype.setTyped = function (...args) {
+  return this.set(...args);
 };
 
+/**
+ * Data types supported by loro
+ */
 export type Value =
   | ContainerID
   | string
   | number
+  | boolean
   | null
   | { [key: string]: Value }
+  | Uint8Array
   | Value[];
 
+
 export type Prelim = PrelimList | PrelimMap | PrelimText;
 
+/**
+ * Represents a path to identify the exact location of an event's target.
+ * The path is composed of numbers (e.g., indices of a list container) and strings 
+ * (e.g., keys of a map container), indicating the absolute position of the event's source
+ * within a loro document.
+ */
 export type Path = (number | string)[];
-export type Delta<T> = {
-  type: "insert";
-  value: T;
-} | {
-  type: "delete";
-  len: number;
-} | {
-  type: "retain";
-  len: number;
-};
+
+/**
+ * The event of Loro.
+ * @prop local - Indicates whether the event is local.
+ * @prop origin - (Optional) Provides information about the origin of the event.
+ * @prop diff - Contains the differential information related to the event.
+ * @prop target - Identifies the container ID of the event's target.
+ * @prop path - Specifies the absolute path of the event's emitter, which can be an index of a list container or a key of a map container.
+ */
+export interface LoroEvent {
+  local: boolean;
+  origin?: string;
+  /**
+   * If true, this event was triggered by a child container.
+   */
+  fromChildren: boolean;
+  /**
+   * If true, this event was triggered by a checkout.
+   */
+  fromCheckout: boolean;
+  diff: Diff;
+  target: ContainerID;
+  path: Path;
+}
 
 export type ListDiff = {
   type: "list";
@@ -136,54 +92,24 @@ export type TextDiff = {
 
 export type MapDiff = {
   type: "map";
-  diff: {
-    added: Record<string, Value>;
-    deleted: Record<string, Value>;
-    updated: Record<string, {
-      old: Value;
-      new: Value;
-    }>;
-  };
+  updated: Record<string, Value | undefined>;
 };
 
-export type Diff = ListDiff | TextDiff | MapDiff;
-
-export interface LoroEvent {
-  local: boolean;
-  origin?: string;
-  diff: Diff;
-  target: ContainerID;
-  path: Path;
+export type TreeDiff = {
+  type: "tree";
+  diff: {target: TreeID, action: "create"|"delete" } | {target: TreeID; action:"move"; parent: TreeID};
 }
 
+export type Diff = ListDiff | TextDiff | MapDiff | TreeDiff;
+
 interface Listener {
   (event: LoroEvent): void;
 }
 
-const CONTAINER_TYPES = ["Map", "Text", "List"];
+const CONTAINER_TYPES = ["Map", "Text", "List", "Tree"];
 
 export function isContainerId(s: string): s is ContainerID {
-  try {
-    if (s.startsWith("/")) {
-      const [_, type] = s.slice(1).split(":");
-      if (!CONTAINER_TYPES.includes(type)) {
-        return false;
-      }
-    } else {
-      const [id, type] = s.split(":");
-      if (!CONTAINER_TYPES.includes(type)) {
-        return false;
-      }
-
-      const [counter, client] = id.split("@");
-      Number.parseInt(counter);
-      Number.parseInt(client);
-    }
-
-    return true;
-  } catch (e) {
-    return false;
-  }
+  return s.startsWith("cid:");
 }
 
 export { Loro };
@@ -191,98 +117,50 @@ export { Loro };
 declare module "loro-wasm" {
   interface Loro {
     subscribe(listener: Listener): number;
-    transact(f: (tx: Transaction) => void, origin?: string): void;
   }
 
   interface Loro<T extends Record<string, any> = Record<string, any>> {
-    getTypedMap<Key extends (keyof T) & string>(
+    getTypedMap<Key extends keyof T & string>(
       name: Key,
     ): T[Key] extends LoroMap ? T[Key] : never;
-    getTypedList<Key extends (keyof T) & string>(
+    getTypedList<Key extends keyof T & string>(
       name: Key,
     ): T[Key] extends LoroList ? T[Key] : never;
   }
 
   interface LoroList<T extends any[] = any[]> {
-    insertContainer(
-      txn: Transaction | Loro,
-      pos: number,
-      container: "Map",
-    ): LoroMap;
-    insertContainer(
-      txn: Transaction | Loro,
-      pos: number,
-      container: "List",
-    ): LoroList;
-    insertContainer(
-      txn: Transaction | Loro,
-      pos: number,
-      container: "Text",
-    ): LoroText;
-    insertContainer(
-      txn: Transaction | Loro,
-      pos: number,
-      container: string,
-    ): never;
+    insertContainer(pos: number, container: "Map"): LoroMap;
+    insertContainer(pos: number, container: "List"): LoroList;
+    insertContainer(pos: number, container: "Text"): LoroText;
+    insertContainer(pos: number, container: "Tree"): LoroTree;
+    insertContainer(pos: number, container: string): never;
 
     get(index: number): Value;
-    getTyped<Key extends (keyof T) & number>(loro: Loro, index: Key): T[Key];
-    insertTyped<Key extends (keyof T) & number>(
-      txn: Transaction | Loro,
-      pos: Key,
-      value: T[Key],
-    ): void;
-    insert(txn: Transaction | Loro, pos: number, value: Value | Prelim): void;
-    delete(txn: Transaction | Loro, pos: number, len: number): void;
-    subscribe(txn: Transaction | Loro, listener: Listener): number;
-    subscribeDeep(txn: Transaction | Loro, listener: Listener): number;
-    subscribeOnce(txn: Transaction | Loro, listener: Listener): number;
+    getTyped<Key extends keyof T & number>(loro: Loro, index: Key): T[Key];
+    insertTyped<Key extends keyof T & number>(pos: Key, value: T[Key]): void;
+    insert(pos: number, value: Value | Prelim): void;
+    delete(pos: number, len: number): void;
+    subscribe(txn: Loro, listener: Listener): number;
   }
 
   interface LoroMap<T extends Record<string, any> = Record<string, any>> {
-    insertContainer(
-      txn: Transaction | Loro,
-      key: string,
-      container_type: "Map",
-    ): LoroMap;
-    insertContainer(
-      txn: Transaction | Loro,
-      key: string,
-      container_type: "List",
-    ): LoroList;
-    insertContainer(
-      txn: Transaction | Loro,
-      key: string,
-      container_type: "Text",
-    ): LoroText;
-    insertContainer(
-      txn: Transaction | Loro,
-      key: string,
-      container_type: string,
-    ): never;
+    setContainer(key: string, container_type: "Map"): LoroMap;
+    setContainer(key: string, container_type: "List"): LoroList;
+    setContainer(key: string, container_type: "Text"): LoroText;
+    setContainer(key: string, container_type: "Tree"): LoroTree;
+    setContainer(key: string, container_type: string): never;
 
     get(key: string): Value;
-    getTyped<Key extends (keyof T) & string>(
-      txn: Loro,
-      key: Key,
-    ): T[Key];
-    set(txn: Transaction | Loro, key: string, value: Value | Prelim): void;
-    setTyped<Key extends (keyof T) & string>(
-      txn: Transaction | Loro,
-      key: Key,
-      value: T[Key],
-    ): void;
-    delete(txn: Transaction | Loro, key: string): void;
-    subscribe(txn: Transaction | Loro, listener: Listener): number;
-    subscribeDeep(txn: Transaction | Loro, listener: Listener): number;
-    subscribeOnce(txn: Transaction | Loro, listener: Listener): number;
+    getTyped<Key extends keyof T & string>(txn: Loro, key: Key): T[Key];
+    set(key: string, value: Value | Prelim): void;
+    setTyped<Key extends keyof T & string>(key: Key, value: T[Key]): void;
+    delete(key: string): void;
+    subscribe(txn: Loro, listener: Listener): number;
   }
 
   interface LoroText {
-    insert(txn: Transaction | Loro, pos: number, text: string): void;
-    delete(txn: Transaction | Loro, pos: number, len: number): void;
-    subscribe(txn: Transaction | Loro, listener: Listener): number;
-    subscribeDeep(txn: Transaction | Loro, listener: Listener): number;
-    subscribeOnce(txn: Transaction | Loro, listener: Listener): number;
+    insert(pos: number, text: string): void;
+    delete(pos: number, len: number): void;
+    subscribe(txn: Loro, listener: Listener): number;
   }
 }

package/vite.config.ts

@@ -4,5 +4,5 @@ import { defineConfig } from "vite";
 
 export default defineConfig({
   plugins: [wasm()],
-  test: {},
+  // test: {},
 });

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "deno.enable": false
-}

package/tests/event.test.ts

@@ -1,261 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  Delta,
-  ListDiff,
-  Loro,
-  LoroEvent,
-  MapDiff as MapDiff,
-  TextDiff,
-} from "../src";
-
-describe("event", () => {
-  it("target", async () => {
-    const loro = new Loro();
-    let lastEvent: undefined | LoroEvent;
-    loro.subscribe((event) => {
-      lastEvent = event;
-    });
-    const text = loro.getText("text");
-    const id = text.id;
-    text.insert(loro, 0, "123");
-    await zeroMs();
-    expect(lastEvent?.target).toEqual(id);
-  });
-
-  it("path", async () => {
-    const loro = new Loro();
-    let lastEvent: undefined | LoroEvent;
-    loro.subscribe((event) => {
-      lastEvent = event;
-    });
-    const map = loro.getMap("map");
-    const subMap = map.insertContainer(loro, "sub", "Map");
-    subMap.set(loro, "0", "1");
-    await zeroMs();
-    expect(lastEvent?.path).toStrictEqual(["map", "sub"]);
-    const list = subMap.insertContainer(loro, "list", "List");
-    list.insert(loro, 0, "2");
-    const text = list.insertContainer(loro, 1, "Text");
-    await zeroMs();
-    text.insert(loro, 0, "3");
-    await zeroMs();
-    expect(lastEvent?.path).toStrictEqual(["map", "sub", "list", 1]);
-  });
-
-  it("text diff", async () => {
-    const loro = new Loro();
-    let lastEvent: undefined | LoroEvent;
-    loro.subscribe((event) => {
-      lastEvent = event;
-    });
-    const text = loro.getText("t");
-    text.insert(loro, 0, "3");
-    await zeroMs();
-    expect(lastEvent?.diff).toStrictEqual(
-      { type: "text", diff: [{ type: "insert", value: "3" }] } as TextDiff,
-    );
-    text.insert(loro, 1, "12");
-    await zeroMs();
-    expect(lastEvent?.diff).toStrictEqual(
-      {
-        type: "text",
-        diff: [{ type: "retain", len: 1 }, { type: "insert", value: "12" }],
-      } as TextDiff,
-    );
-  });
-
-  it("list diff", async () => {
-    const loro = new Loro();
-    let lastEvent: undefined | LoroEvent;
-    loro.subscribe((event) => {
-      lastEvent = event;
-    });
-    const text = loro.getList("l");
-    text.insert(loro, 0, "3");
-    await zeroMs();
-    expect(lastEvent?.diff).toStrictEqual(
-      { type: "list", diff: [{ type: "insert", value: ["3"] }] } as ListDiff,
-    );
-    text.insert(loro, 1, "12");
-    await zeroMs();
-    expect(lastEvent?.diff).toStrictEqual(
-      {
-        type: "list",
-        diff: [{ type: "retain", len: 1 }, { type: "insert", value: ["12"] }],
-      } as ListDiff,
-    );
-  });
-
-  it("map diff", async () => {
-    const loro = new Loro();
-    let lastEvent: undefined | LoroEvent;
-    loro.subscribe((event) => {
-      lastEvent = event;
-    });
-    const map = loro.getMap("m");
-    loro.transact((tx) => {
-      map.set(tx, "0", "3");
-      map.set(tx, "1", "2");
-    });
-    await zeroMs();
-    expect(lastEvent?.diff).toStrictEqual(
-      {
-        type: "map",
-        diff: {
-          added: {
-            "0": "3",
-            "1": "2",
-          },
-          deleted: {},
-          updated: {},
-        },
-      } as MapDiff,
-    );
-    loro.transact((tx) => {
-      map.set(tx, "0", "0");
-      map.set(tx, "1", "1");
-    });
-    await zeroMs();
-    expect(lastEvent?.diff).toStrictEqual(
-      {
-        type: "map",
-        diff: {
-          added: {},
-          updated: {
-            "0": { old: "3", new: "0" },
-            "1": { old: "2", new: "1" },
-          },
-          deleted: {},
-        },
-      } as MapDiff,
-    );
-  });
-
-  describe("subscribe container events", () => {
-    it("text", async () => {
-      const loro = new Loro();
-      const text = loro.getText("text");
-      let ran = 0;
-      let oneTimeRan = 0;
-      text.subscribeOnce(loro, (_) => {
-        oneTimeRan += 1;
-      });
-      const sub = text.subscribe(loro, (event) => {
-        if (!ran) {
-          expect(event.diff.diff).toStrictEqual(
-            [{ type: "insert", "value": "123" }] as Delta<string>[],
-          );
-        }
-        ran += 1;
-        expect(event.target).toBe(text.id);
-      });
-      text.insert(loro, 0, "123");
-      text.insert(loro, 1, "456");
-      await zeroMs();
-      expect(ran).toBeTruthy();
-      // subscribeOnce test
-      expect(oneTimeRan).toBe(1);
-      expect(text.toString()).toEqual("145623");
-
-      // unsubscribe
-      const oldRan = ran;
-      text.unsubscribe(loro, sub);
-      text.insert(loro, 0, "789");
-      expect(ran).toBe(oldRan);
-    });
-
-    it("map subscribe deep", async () => {
-      const loro = new Loro();
-      const map = loro.getMap("map");
-      let times = 0;
-      const sub = map.subscribeDeep(loro, (event) => {
-        times += 1;
-      });
-
-      const subMap = map.insertContainer(loro, "sub", "Map");
-      await zeroMs();
-      expect(times).toBe(1);
-      const text = subMap.insertContainer(loro, "k", "Text");
-      await zeroMs();
-      expect(times).toBe(2);
-      text.insert(loro, 0, "123");
-      await zeroMs();
-      expect(times).toBe(3);
-
-      // unsubscribe
-      map.unsubscribe(loro, sub);
-      text.insert(loro, 0, "123");
-      await zeroMs();
-      expect(times).toBe(3);
-    });
-
-    it("list subscribe deep", async () => {
-      const loro = new Loro();
-      const list = loro.getList("list");
-      let times = 0;
-      const sub = list.subscribeDeep(loro, (_) => {
-        times += 1;
-      });
-
-      const text = list.insertContainer(loro, 0, "Text");
-      await zeroMs();
-      expect(times).toBe(1);
-      text.insert(loro, 0, "123");
-      await zeroMs();
-      expect(times).toBe(2);
-
-      // unsubscribe
-      list.unsubscribe(loro, sub);
-      text.insert(loro, 0, "123");
-      await zeroMs();
-      expect(times).toBe(2);
-    });
-  });
-
-  describe("text event length should be utf16", () => {
-    it("test", async () => {
-      const loro = new Loro();
-      const text = loro.getText("text");
-      let string = "";
-      text.subscribe(loro, (event) => {
-        const diff = event.diff;
-        expect(diff.type).toBe("text");
-        if (diff.type === "text") {
-          let newString = "";
-          let pos = 0;
-          for (const delta of diff.diff) {
-            if (delta.type === "retain") {
-              pos += delta.len;
-              newString += string.slice(0, pos);
-            } else if (delta.type === "insert") {
-              newString += delta.value;
-            } else {
-              pos += delta.len;
-            }
-          }
-
-          string = newString + string.slice(pos);
-        }
-      });
-      text.insert(loro, 0, "你好");
-      await zeroMs();
-      expect(text.toString()).toBe(string);
-
-      text.insert(loro, 1, "世界");
-      await zeroMs();
-      expect(text.toString()).toBe(string);
-
-      text.insert(loro, 2, "👍");
-      await zeroMs();
-      expect(text.toString()).toBe(string);
-
-      text.insert(loro, 4, "♪(^∇^*)");
-      await zeroMs();
-      expect(text.toString()).toBe(string);
-    });
-  });
-});
-
-function zeroMs(): Promise<void> {
-  return new Promise((r) => setTimeout(r));
-}

package/tests/frontiers.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  Delta,
-  ListDiff,
-  Loro,
-  LoroEvent,
-  MapDiff as MapDiff,
-  TextDiff,
-} from "../src";
-
-describe("Frontiers", () => {
-  it("two clients", () => {
-    const doc = new Loro();
-    const text = doc.getText("text");
-    text.insert(doc, 0, "0");
-    const v0 = doc.frontiers();
-    const docB = new Loro();
-    docB.import(doc.exportFrom());
-    expect(docB.cmpFrontiers(v0)).toBe(0);
-    text.insert(doc, 1, "0");
-    expect(docB.cmpFrontiers(doc.frontiers())).toBe(-1);
-    const textB = docB.getText("text");
-    textB.insert(docB, 0, "0");
-    expect(docB.cmpFrontiers(doc.frontiers())).toBe(-1);
-    docB.import(doc.exportFrom());
-    expect(docB.cmpFrontiers(doc.frontiers())).toBe(1);
-    doc.import(docB.exportFrom());
-    expect(docB.cmpFrontiers(doc.frontiers())).toBe(0);
-  });
-});