loro-crdt 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 0.14.0
+
+### Minor Changes
+
+- Improved API
+
+  ### 🚀 Features
+
+  - Access value/container by path (#308)
+  - Decode import blob meta (#307)
+
+  ### 🐛 Bug Fixes
+
+  - Decode iter return result by updating columnar to 0.3.4 (#309)
+
+  ### 🚜 Refactor
+
+  - Replace "local" and "fromCheckout" in event with "triggeredBy" (#312)
+  - Add concrete type for each different container (#313)
+  - _(ts)_ Make types better (#315)
+
+  ### 📚 Documentation
+
+  - Refine wasm docs (#304)
+  - Clarify that peer id should be convertible to a u64 (#306)
+
+  ### ⚙️ Miscellaneous Tasks
+
+  - Add coverage report cli (#311)
+
+### Patch Changes
+
+- Updated dependencies
+  - loro-wasm@0.14.0
+
+## 0.13.1
+
+### Patch Changes
+
+- Fix type errors and conversion from js->rust error
+- Updated dependencies
+  - loro-wasm@0.13.1
+
 ## 0.13.0
 
 ### Minor Changes

package/dist/loro.d.ts

@@ -1,4 +1,4 @@
-import { Container, Value, TreeID, OpId, ContainerID, Delta, LoroText, LoroMap, LoroTree, LoroList } from 'loro-wasm';
+import { Container, ContainerID, TreeID, OpId, Delta, Value, LoroText, LoroMap, LoroTree, LoroList } from 'loro-wasm';
 export * from 'loro-wasm';
 export { Loro } from 'loro-wasm';
 
@@ -13,18 +13,21 @@ type Path = (number | string | TreeID)[];
 /**
  * A batch of events that created by a single `import`/`transaction`/`checkout`.
  *
- * @prop local - Indicates whether the event is local.
+ * @prop by - How the event is triggered.
  * @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.
  */
 interface LoroEventBatch {
-    local: boolean;
     /**
-     * If true, this event was triggered by a checkout.
+     * How the event is triggered.
+     *
+     * - `local`: The event is triggered by a local transaction.
+     * - `import`: The event is triggered by an import operation.
+     * - `checkout`: The event is triggered by a checkout operation.
      */
-    fromCheckout: boolean;
+    by: "local" | "import" | "checkout";
     origin?: string;
     /**
      * The container ID of the current event receiver.
@@ -115,60 +118,228 @@ declare function isContainer(value: any): value is Container;
  * getType({}); // "Json"
  * ```
  */
-declare function getType<T>(value: T): T extends LoroText ? "Text" : T extends LoroMap ? "Map" : T extends LoroTree ? "Tree" : T extends LoroList ? "List" : "Json";
+declare function getType<T>(value: T): T extends LoroText ? "Text" : T extends LoroMap<any> ? "Map" : T extends LoroTree<any> ? "Tree" : T extends LoroList<any> ? "List" : "Json";
 declare module "loro-wasm" {
     interface Loro {
         subscribe(listener: Listener): number;
     }
-    interface Loro<T extends Record<string, any> = Record<string, any>> {
-        getTypedMap<Key extends keyof T & string>(name: Key): T[Key] extends LoroMap ? T[Key] : never;
-        getTypedList<Key extends keyof T & string>(name: Key): T[Key] extends LoroList ? T[Key] : never;
+    interface Loro<T extends Record<string, Container> = Record<string, Container>> {
+        /**
+         * Get a LoroMap by container id
+         *
+         * The object returned is a new js object each time because it need to cross
+         * the WASM boundary.
+         *
+         * @example
+         * ```ts
+         * import { Loro } from "loro-crdt";
+         *
+         * const doc = new Loro();
+         * const map = doc.getMap("map");
+         * ```
+         */
+        getMap<Key extends keyof T>(name: Key): T[Key] extends LoroMap ? T[Key] : LoroMap;
+        /**
+         * Get a LoroList by container id
+         *
+         * The object returned is a new js object each time because it need to cross
+         * the WASM boundary.
+         *
+         * @example
+         * ```ts
+         * import { Loro } from "loro-crdt";
+         *
+         * const doc = new Loro();
+         * const list = doc.getList("list");
+         * ```
+         */
+        getList<Key extends keyof T>(name: Key): T[Key] extends LoroList ? T[Key] : LoroList;
+        /**
+         * Get a LoroTree by container id
+         *
+         *  The object returned is a new js object each time because it need to cross
+         *  the WASM boundary.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const tree = doc.getTree("tree");
+         *  ```
+         */
+        getTree<Key extends keyof T>(name: Key): T[Key] extends LoroTree ? T[Key] : LoroTree;
+        getText(key: string | ContainerID): LoroText;
     }
-    interface LoroList<T extends any[] = any[]> {
-        insertContainer<C extends Container>(pos: number, child: C): C;
-        get(index: number): undefined | Value | Container;
-        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: Container): never;
-        insert(pos: number, value: Value): void;
+    interface LoroList<T = unknown> {
+        new (): LoroList<T>;
+        /**
+         *  Get elements of the list. If the value is a child container, the corresponding
+         *  `Container` will be returned.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const list = doc.getList("list");
+         *  list.insert(0, 100);
+         *  list.insert(1, "foo");
+         *  list.insert(2, true);
+         *  list.insertContainer(3, new LoroText());
+         *  console.log(list.value);  // [100, "foo", true, LoroText];
+         *  ```
+         */
+        toArray(): T[];
+        /**
+         * Insert a container at the index.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const list = doc.getList("list");
+         *  list.insert(0, 100);
+         *  const text = list.insertContainer(1, new LoroText());
+         *  text.insert(0, "Hello");
+         *  console.log(list.getDeepValue());  // [100, "Hello"];
+         *  ```
+         */
+        insertContainer<C extends Container>(pos: number, child: C): T extends C ? T : C;
+        /**
+         * Get the value at the index. If the value is a container, the corresponding handler will be returned.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const list = doc.getList("list");
+         *  list.insert(0, 100);
+         *  console.log(list.get(0));  // 100
+         *  console.log(list.get(1));  // undefined
+         *  ```
+         */
+        get(index: number): T;
+        /**
+         *  Insert a value at index.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const list = doc.getList("list");
+         *  list.insert(0, 100);
+         *  list.insert(1, "foo");
+         *  list.insert(2, true);
+         *  console.log(list.value);  // [100, "foo", true];
+         *  ```
+         */
+        insert(pos: number, value: Exclude<T, Container>): void;
         delete(pos: number, len: number): void;
         subscribe(txn: Loro, listener: Listener): number;
+        getAttached(): undefined | LoroList<T>;
     }
-    interface LoroMap<T extends Record<string, any> = Record<string, any>> {
-        getOrCreateContainer(key: string, container_type: "Map"): LoroMap;
-        getOrCreateContainer(key: string, container_type: "List"): LoroList;
-        getOrCreateContainer(key: string, container_type: "Text"): LoroText;
-        getOrCreateContainer(key: string, container_type: "Tree"): LoroTree;
-        getOrCreateContainer(key: string, container_type: string): never;
-        setContainer<C extends Container>(key: string, child: C): C;
-        get(key: string): undefined | Value | Container;
-        getTyped<Key extends keyof T & string>(txn: Loro, key: Key): T[Key];
-        set(key: string, value: Value): void;
-        setTyped<Key extends keyof T & string>(key: Key, value: T[Key]): void;
+    interface LoroMap<T extends Record<string, unknown> = Record<string, unknown>> {
+        new (): LoroMap<T>;
+        /**
+         *  Get the value of the key. If the value is a child container, the corresponding
+         *  `Container` will be returned.
+         *
+         *  The object returned is a new js object each time because it need to cross
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const map = doc.getMap("map");
+         *  map.set("foo", "bar");
+         *  const bar = map.get("foo");
+         *  ```
+         */
+        getOrCreateContainer<C extends Container>(key: string, child: C): C;
+        /**
+         * Set the key with a container.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const map = doc.getMap("map");
+         *  map.set("foo", "bar");
+         *  const text = map.setContainer("text", new LoroText());
+         *  const list = map.setContainer("list", new LoroText());
+         *  ```
+         */
+        setContainer<C extends Container, Key extends keyof T>(key: Key, child: C): NonNullableType<T[Key]> extends C ? NonNullableType<T[Key]> : C;
+        /**
+         *  Get the value of the key. If the value is a child container, the corresponding
+         *  `Container` will be returned.
+         *
+         *  The object/value returned is a new js object/value each time because it need to cross
+         *  the WASM boundary.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const map = doc.getMap("map");
+         *  map.set("foo", "bar");
+         *  const bar = map.get("foo");
+         *  ```
+         */
+        get<Key extends keyof T>(key: Key): T[Key];
+        /**
+         * Set the key with the value.
+         *
+         *  If the value of the key is exist, the old value will be updated.
+         *
+         *  @example
+         *  ```ts
+         *  import { Loro } from "loro-crdt";
+         *
+         *  const doc = new Loro();
+         *  const map = doc.getMap("map");
+         *  map.set("foo", "bar");
+         *  map.set("foo", "baz");
+         *  ```
+         */
+        set<Key extends keyof T>(key: Key, value: Exclude<T[Key], Container>): void;
         delete(key: string): void;
         subscribe(txn: Loro, listener: Listener): number;
     }
     interface LoroText {
+        new (): LoroText;
         insert(pos: number, text: string): void;
         delete(pos: number, len: number): void;
         subscribe(txn: Loro, listener: Listener): number;
     }
-    interface LoroTree {
-        createNode(parent: TreeID | undefined): LoroTreeNode;
+    interface LoroTree<T extends Record<string, unknown> = Record<string, unknown>> {
+        new (): LoroTree<T>;
+        createNode(parent: TreeID | undefined): LoroTreeNode<T>;
         move(target: TreeID, parent: TreeID | undefined): void;
         delete(target: TreeID): void;
         has(target: TreeID): boolean;
         getNodeByID(target: TreeID): LoroTreeNode;
         subscribe(txn: Loro, listener: Listener): number;
     }
-    interface LoroTreeNode {
-        readonly data: LoroMap;
-        createNode(): LoroTreeNode;
+    interface LoroTreeNode<T extends Record<string, unknown> = Record<string, unknown>> {
+        /**
+         * Get the associated metadata map container of a tree node.
+         */
+        readonly data: LoroMap<T>;
+        createNode(): LoroTreeNode<T>;
         setAsRoot(): void;
-        moveTo(parent: LoroTreeNode): void;
-        parent(): LoroTreeNode | undefined;
-        children(): Array<LoroTreeNode>;
+        moveTo(parent: LoroTreeNode<T>): void;
+        parent(): LoroTreeNode<T> | undefined;
+        children(): Array<LoroTreeNode<T>>;
     }
 }
+type NonNullableType<T> = Exclude<T, null | undefined>;
 
 export { Diff, Frontiers, ListDiff, LoroEvent, LoroEventBatch, MapDiff, Path, TextDiff, TreeDiff, TreeDiffItem, getType, isContainer, isContainerId };

package/dist/loro.js

@@ -2,34 +2,6 @@
 
 var loroWasm = require('loro-wasm');
 
-loroWasm.Loro.prototype.getTypedMap = function(...args) {
-  return this.getMap(...args);
-};
-loroWasm.Loro.prototype.getTypedList = function(...args) {
-  return this.getList(...args);
-};
-loroWasm.LoroList.prototype.getTyped = function(loro, index) {
-  const value = this.get(index);
-  if (typeof value === "string" && isContainerId(value)) {
-    return loro.getContainerById(value);
-  } else {
-    return value;
-  }
-};
-loroWasm.LoroList.prototype.insertTyped = function(...args) {
-  return this.insert(...args);
-};
-loroWasm.LoroMap.prototype.getTyped = function(loro, key) {
-  const value = this.get(key);
-  if (typeof value === "string" && isContainerId(value)) {
-    return loro.getContainerById(value);
-  } else {
-    return value;
-  }
-};
-loroWasm.LoroMap.prototype.setTyped = function(...args) {
-  return this.set(...args);
-};
 const CONTAINER_TYPES = ["Map", "Text", "List", "Tree"];
 function isContainerId(s) {
   return s.startsWith("cid:");

package/dist/loro.js.map

@@ -1 +1 @@
-{"version":3,"file":"loro.js","sources":["../src/index.ts"],"sourcesContent":["export * from \"loro-wasm\";\nimport {\n  Container,\n  ContainerID,\n  Delta,\n  Loro,\n  LoroList,\n  LoroMap,\n  LoroText,\n  LoroTree,\n  LoroTreeNode,\n  OpId,\n  TreeID,\n  Value,\n} from \"loro-wasm\";\n\nLoro.prototype.getTypedMap = function (...args) {\n  return this.getMap(...args);\n};\nLoro.prototype.getTypedList = function (...args) {\n  return this.getList(...args);\n};\nLoroList.prototype.getTyped = function (loro, index) {\n  const value = this.get(index);\n  if (typeof value === \"string\" && isContainerId(value)) {\n    return loro.getContainerById(value);\n  } else {\n    return value;\n  }\n};\nLoroList.prototype.insertTyped = function (...args) {\n  return this.insert(...args);\n};\nLoroMap.prototype.getTyped = function (loro, key) {\n  const value = this.get(key);\n  if (typeof value === \"string\" && isContainerId(value)) {\n    return loro.getContainerById(value);\n  } else {\n    return value;\n  }\n};\nLoroMap.prototype.setTyped = function (...args) {\n  return this.set(...args);\n};\n\nexport type Frontiers = OpId[];\n\n/**\n * Represents a path to identify the exact location of an event's target.\n * The path is composed of numbers (e.g., indices of a list container) strings\n * (e.g., keys of a map container) and TreeID (the node of a tree container),\n * indicating the absolute position of the event's source within a loro document.\n */\nexport type Path = (number | string | TreeID)[];\n\n/**\n * A batch of events that created by a single `import`/`transaction`/`checkout`.\n *\n * @prop local - Indicates whether the event is local.\n * @prop origin - (Optional) Provides information about the origin of the event.\n * @prop diff - Contains the differential information related to the event.\n * @prop target - Identifies the container ID of the event's target.\n * @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.\n */\nexport interface LoroEventBatch {\n  local: boolean;\n  /**\n   * If true, this event was triggered by a checkout.\n   */\n  fromCheckout: boolean;\n  origin?: string;\n  /**\n   * The container ID of the current event receiver.\n   * It's undefined if the subscriber is on the root document.\n   */\n  currentTarget?: ContainerID;\n  events: LoroEvent[];\n}\n\n/**\n * The concrete event of Loro.\n */\nexport interface LoroEvent {\n  /**\n   * The container ID of the event's target.\n   */\n  target: ContainerID;\n  diff: Diff;\n  /**\n   * The absolute path of the event's emitter, which can be an index of a list container or a key of a map container.\n   */\n  path: Path;\n}\n\nexport type ListDiff = {\n  type: \"list\";\n  diff: Delta<(Value | Container)[]>[];\n};\n\nexport type TextDiff = {\n  type: \"text\";\n  diff: Delta<string>[];\n};\n\nexport type MapDiff = {\n  type: \"map\";\n  updated: Record<string, Value | Container | undefined>;\n};\n\nexport type TreeDiffItem =\n  | { target: TreeID; action: \"create\"; parent: TreeID | undefined }\n  | { target: TreeID; action: \"delete\" }\n  | { target: TreeID; action: \"move\"; parent: TreeID | undefined };\n\nexport type TreeDiff = {\n  type: \"tree\";\n  diff: TreeDiffItem[];\n};\n\nexport type Diff = ListDiff | TextDiff | MapDiff | TreeDiff;\n\ninterface Listener {\n  (event: LoroEventBatch): void;\n}\n\nconst CONTAINER_TYPES = [\"Map\", \"Text\", \"List\", \"Tree\"];\n\nexport function isContainerId(s: string): s is ContainerID {\n  return s.startsWith(\"cid:\");\n}\n\nexport { Loro };\n\n/**  Whether the value is a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * isContainer(map); // true\n * isContainer(list); // true\n * isContainer(text); // true\n * isContainer(123); // false\n * isContainer(\"123\"); // false\n * isContainer({}); // false\n */\nexport function isContainer(value: any): value is Container {\n  if (typeof value !== \"object\" || value == null) {\n    return false;\n  }\n\n  const p = Object.getPrototypeOf(value);\n  if (p == null || typeof p !== \"object\" || typeof p[\"kind\"] !== \"function\") {\n    return false;\n  }\n\n  return CONTAINER_TYPES.includes(value.kind());\n}\n\n/**  Get the type of a value that may be a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * getType(map); // \"Map\"\n * getType(list); // \"List\"\n * getType(text); // \"Text\"\n * getType(123); // \"Json\"\n * getType(\"123\"); // \"Json\"\n * getType({}); // \"Json\"\n * ```\n */\nexport function getType<T>(\n  value: T,\n): T extends LoroText ? \"Text\"\n  : T extends LoroMap ? \"Map\"\n  : T extends LoroTree ? \"Tree\"\n  : T extends LoroList ? \"List\"\n  : \"Json\" {\n  if (isContainer(value)) {\n    return value.kind();\n  }\n\n  return \"Json\" as any;\n}\n\ndeclare module \"loro-wasm\" {\n  interface Loro {\n    subscribe(listener: Listener): number;\n  }\n\n  interface Loro<T extends Record<string, any> = Record<string, any>> {\n    getTypedMap<Key extends keyof T & string>(\n      name: Key,\n    ): T[Key] extends LoroMap ? T[Key] : never;\n    getTypedList<Key extends keyof T & string>(\n      name: Key,\n    ): T[Key] extends LoroList ? T[Key] : never;\n  }\n\n  interface LoroList<T extends any[] = any[]> {\n    insertContainer<C extends Container>(pos: number, child: C): C;\n\n    get(index: number): undefined | Value | Container;\n    getTyped<Key extends keyof T & number>(loro: Loro, index: Key): T[Key];\n    insertTyped<Key extends keyof T & number>(pos: Key, value: T[Key]): void;\n    insert(pos: number, value: Container): never;\n    insert(pos: number, value: Value): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroMap<T extends Record<string, any> = Record<string, any>> {\n    getOrCreateContainer(key: string, container_type: \"Map\"): LoroMap;\n    getOrCreateContainer(key: string, container_type: \"List\"): LoroList;\n    getOrCreateContainer(key: string, container_type: \"Text\"): LoroText;\n    getOrCreateContainer(key: string, container_type: \"Tree\"): LoroTree;\n    getOrCreateContainer(key: string, container_type: string): never;\n\n    setContainer<C extends Container>(key: string, child: C): C;\n\n    get(key: string): undefined | Value | Container;\n    getTyped<Key extends keyof T & string>(txn: Loro, key: Key): T[Key];\n    set(key: string, value: Value): void;\n    setTyped<Key extends keyof T & string>(key: Key, value: T[Key]): void;\n    delete(key: string): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroText {\n    insert(pos: number, text: string): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTree {\n    createNode(parent: TreeID | undefined): LoroTreeNode;\n    move(target: TreeID, parent: TreeID | undefined): void;\n    delete(target: TreeID): void;\n    has(target: TreeID): boolean;\n    getNodeByID(target: TreeID): LoroTreeNode;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTreeNode {\n    readonly data: LoroMap;\n    createNode(): LoroTreeNode;\n    setAsRoot(): void;\n    moveTo(parent: LoroTreeNode): void;\n    parent(): LoroTreeNode | undefined;\n    children(): Array<LoroTreeNode>;\n  }\n}\n"],"names":["Loro","LoroList","LoroMap"],"mappings":";;;;AAgBAA,aAAK,CAAA,SAAA,CAAU,WAAc,GAAA,SAAA,GAAa,IAAM,EAAA;AAC9C,EAAO,OAAA,IAAA,CAAK,MAAO,CAAA,GAAG,IAAI,CAAA,CAAA;AAC5B,CAAA,CAAA;AACAA,aAAK,CAAA,SAAA,CAAU,YAAe,GAAA,SAAA,GAAa,IAAM,EAAA;AAC/C,EAAO,OAAA,IAAA,CAAK,OAAQ,CAAA,GAAG,IAAI,CAAA,CAAA;AAC7B,CAAA,CAAA;AACAC,iBAAA,CAAS,SAAU,CAAA,QAAA,GAAW,SAAU,IAAA,EAAM,KAAO,EAAA;AACnD,EAAM,MAAA,KAAA,GAAQ,IAAK,CAAA,GAAA,CAAI,KAAK,CAAA,CAAA;AAC5B,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,aAAA,CAAc,KAAK,CAAG,EAAA;AACrD,IAAO,OAAA,IAAA,CAAK,iBAAiB,KAAK,CAAA,CAAA;AAAA,GAC7B,MAAA;AACL,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AACF,CAAA,CAAA;AACAA,iBAAS,CAAA,SAAA,CAAU,WAAc,GAAA,SAAA,GAAa,IAAM,EAAA;AAClD,EAAO,OAAA,IAAA,CAAK,MAAO,CAAA,GAAG,IAAI,CAAA,CAAA;AAC5B,CAAA,CAAA;AACAC,gBAAA,CAAQ,SAAU,CAAA,QAAA,GAAW,SAAU,IAAA,EAAM,GAAK,EAAA;AAChD,EAAM,MAAA,KAAA,GAAQ,IAAK,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC1B,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,aAAA,CAAc,KAAK,CAAG,EAAA;AACrD,IAAO,OAAA,IAAA,CAAK,iBAAiB,KAAK,CAAA,CAAA;AAAA,GAC7B,MAAA;AACL,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AACF,CAAA,CAAA;AACAA,gBAAQ,CAAA,SAAA,CAAU,QAAW,GAAA,SAAA,GAAa,IAAM,EAAA;AAC9C,EAAO,OAAA,IAAA,CAAK,GAAI,CAAA,GAAG,IAAI,CAAA,CAAA;AACzB,CAAA,CAAA;AAkFA,MAAM,eAAkB,GAAA,CAAC,KAAO,EAAA,MAAA,EAAQ,QAAQ,MAAM,CAAA,CAAA;AAE/C,SAAS,cAAc,CAA6B,EAAA;AACzD,EAAO,OAAA,CAAA,CAAE,WAAW,MAAM,CAAA,CAAA;AAC5B,CAAA;AAoBO,SAAS,YAAY,KAAgC,EAAA;AAC1D,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,KAAA,IAAS,IAAM,EAAA;AAC9C,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAM,MAAA,CAAA,GAAI,MAAO,CAAA,cAAA,CAAe,KAAK,CAAA,CAAA;AACrC,EAAI,IAAA,CAAA,IAAK,QAAQ,OAAO,CAAA,KAAM,YAAY,OAAO,CAAA,CAAE,MAAM,CAAA,KAAM,UAAY,EAAA;AACzE,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAA,OAAO,eAAgB,CAAA,QAAA,CAAS,KAAM,CAAA,IAAA,EAAM,CAAA,CAAA;AAC9C,CAAA;AAmBO,SAAS,QACd,KAKS,EAAA;AACT,EAAI,IAAA,WAAA,CAAY,KAAK,CAAG,EAAA;AACtB,IAAA,OAAO,MAAM,IAAK,EAAA,CAAA;AAAA,GACpB;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"loro.js","sources":["../src/index.ts"],"sourcesContent":["export * from \"loro-wasm\";\nimport {\n  Container,\n  ContainerID,\n  Delta,\n  Loro,\n  LoroList,\n  LoroMap,\n  LoroText,\n  LoroTree,\n  OpId,\n  TreeID,\n  Value,\n} from \"loro-wasm\";\n\nexport type Frontiers = OpId[];\n\n/**\n * Represents a path to identify the exact location of an event's target.\n * The path is composed of numbers (e.g., indices of a list container) strings\n * (e.g., keys of a map container) and TreeID (the node of a tree container),\n * indicating the absolute position of the event's source within a loro document.\n */\nexport type Path = (number | string | TreeID)[];\n\n/**\n * A batch of events that created by a single `import`/`transaction`/`checkout`.\n *\n * @prop by - How the event is triggered.\n * @prop origin - (Optional) Provides information about the origin of the event.\n * @prop diff - Contains the differential information related to the event.\n * @prop target - Identifies the container ID of the event's target.\n * @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.\n */\nexport interface LoroEventBatch {\n  /**\n   * How the event is triggered.\n   *\n   * - `local`: The event is triggered by a local transaction.\n   * - `import`: The event is triggered by an import operation.\n   * - `checkout`: The event is triggered by a checkout operation.\n   */\n  by: \"local\" | \"import\" | \"checkout\";\n  origin?: string;\n  /**\n   * The container ID of the current event receiver.\n   * It's undefined if the subscriber is on the root document.\n   */\n  currentTarget?: ContainerID;\n  events: LoroEvent[];\n}\n\n/**\n * The concrete event of Loro.\n */\nexport interface LoroEvent {\n  /**\n   * The container ID of the event's target.\n   */\n  target: ContainerID;\n  diff: Diff;\n  /**\n   * The absolute path of the event's emitter, which can be an index of a list container or a key of a map container.\n   */\n  path: Path;\n}\n\nexport type ListDiff = {\n  type: \"list\";\n  diff: Delta<(Value | Container)[]>[];\n};\n\nexport type TextDiff = {\n  type: \"text\";\n  diff: Delta<string>[];\n};\n\nexport type MapDiff = {\n  type: \"map\";\n  updated: Record<string, Value | Container | undefined>;\n};\n\nexport type TreeDiffItem =\n  | { target: TreeID; action: \"create\"; parent: TreeID | undefined }\n  | { target: TreeID; action: \"delete\" }\n  | { target: TreeID; action: \"move\"; parent: TreeID | undefined };\n\nexport type TreeDiff = {\n  type: \"tree\";\n  diff: TreeDiffItem[];\n};\n\nexport type Diff = ListDiff | TextDiff | MapDiff | TreeDiff;\n\ninterface Listener {\n  (event: LoroEventBatch): void;\n}\n\nconst CONTAINER_TYPES = [\"Map\", \"Text\", \"List\", \"Tree\"];\n\nexport function isContainerId(s: string): s is ContainerID {\n  return s.startsWith(\"cid:\");\n}\n\nexport { Loro };\n\n/**  Whether the value is a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * isContainer(map); // true\n * isContainer(list); // true\n * isContainer(text); // true\n * isContainer(123); // false\n * isContainer(\"123\"); // false\n * isContainer({}); // false\n */\nexport function isContainer(value: any): value is Container {\n  if (typeof value !== \"object\" || value == null) {\n    return false;\n  }\n\n  const p = Object.getPrototypeOf(value);\n  if (p == null || typeof p !== \"object\" || typeof p[\"kind\"] !== \"function\") {\n    return false;\n  }\n\n  return CONTAINER_TYPES.includes(value.kind());\n}\n\n/**  Get the type of a value that may be a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * getType(map); // \"Map\"\n * getType(list); // \"List\"\n * getType(text); // \"Text\"\n * getType(123); // \"Json\"\n * getType(\"123\"); // \"Json\"\n * getType({}); // \"Json\"\n * ```\n */\nexport function getType<T>(\n  value: T,\n): T extends LoroText ? \"Text\"\n  : T extends LoroMap<any> ? \"Map\"\n  : T extends LoroTree<any> ? \"Tree\"\n  : T extends LoroList<any> ? \"List\"\n  : \"Json\" {\n  if (isContainer(value)) {\n    return value.kind() as unknown as any;\n  }\n\n  return \"Json\" as any;\n}\n\ndeclare module \"loro-wasm\" {\n  interface Loro {\n    subscribe(listener: Listener): number;\n  }\n\n  interface Loro<\n    T extends Record<string, Container> = Record<string, Container>,\n  > {\n    /**\n     * Get a LoroMap by container id\n     *\n     * The object returned is a new js object each time because it need to cross\n     * the WASM boundary.\n     *\n     * @example\n     * ```ts\n     * import { Loro } from \"loro-crdt\";\n     *\n     * const doc = new Loro();\n     * const map = doc.getMap(\"map\");\n     * ```\n     */\n    getMap<Key extends keyof T>(\n      name: Key,\n    ): T[Key] extends LoroMap ? T[Key] : LoroMap;\n    /**\n     * Get a LoroList by container id\n     *\n     * The object returned is a new js object each time because it need to cross\n     * the WASM boundary.\n     *\n     * @example\n     * ```ts\n     * import { Loro } from \"loro-crdt\";\n     *\n     * const doc = new Loro();\n     * const list = doc.getList(\"list\");\n     * ```\n     */\n    getList<Key extends keyof T>(\n      name: Key,\n    ): T[Key] extends LoroList ? T[Key] : LoroList;\n    /**\n     * Get a LoroTree by container id\n     *\n     *  The object returned is a new js object each time because it need to cross\n     *  the WASM boundary.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const tree = doc.getTree(\"tree\");\n     *  ```\n     */\n    getTree<Key extends keyof T>(\n      name: Key,\n    ): T[Key] extends LoroTree ? T[Key] : LoroTree;\n    getText(key: string | ContainerID): LoroText;\n  }\n\n  interface LoroList<T = unknown> {\n    new (): LoroList<T>;\n    /**\n     *  Get elements of the list. If the value is a child container, the corresponding\n     *  `Container` will be returned.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  list.insert(1, \"foo\");\n     *  list.insert(2, true);\n     *  list.insertContainer(3, new LoroText());\n     *  console.log(list.value);  // [100, \"foo\", true, LoroText];\n     *  ```\n     */\n    toArray(): T[];\n    /**\n     * Insert a container at the index.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  const text = list.insertContainer(1, new LoroText());\n     *  text.insert(0, \"Hello\");\n     *  console.log(list.getDeepValue());  // [100, \"Hello\"];\n     *  ```\n     */\n    insertContainer<C extends Container>(\n      pos: number,\n      child: C,\n    ): T extends C ? T : C;\n    /**\n     * Get the value at the index. If the value is a container, the corresponding handler will be returned.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  console.log(list.get(0));  // 100\n     *  console.log(list.get(1));  // undefined\n     *  ```\n     */\n    get(index: number): T;\n    /**\n     *  Insert a value at index.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  list.insert(1, \"foo\");\n     *  list.insert(2, true);\n     *  console.log(list.value);  // [100, \"foo\", true];\n     *  ```\n     */\n    insert(pos: number, value: Exclude<T, Container>): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n    getAttached(): undefined | LoroList<T>;\n  }\n\n  interface LoroMap<\n    T extends Record<string, unknown> = Record<string, unknown>,\n  > {\n    new (): LoroMap<T>;\n    /**\n     *  Get the value of the key. If the value is a child container, the corresponding\n     *  `Container` will be returned.\n     *\n     *  The object returned is a new js object each time because it need to cross\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  const bar = map.get(\"foo\");\n     *  ```\n     */\n    getOrCreateContainer<C extends Container>(key: string, child: C): C;\n    /**\n     * Set the key with a container.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  const text = map.setContainer(\"text\", new LoroText());\n     *  const list = map.setContainer(\"list\", new LoroText());\n     *  ```\n     */\n    setContainer<C extends Container, Key extends keyof T>(\n      key: Key,\n      child: C,\n    ): NonNullableType<T[Key]> extends C ? NonNullableType<T[Key]> : C;\n    /**\n     *  Get the value of the key. If the value is a child container, the corresponding\n     *  `Container` will be returned.\n     *\n     *  The object/value returned is a new js object/value each time because it need to cross\n     *  the WASM boundary.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  const bar = map.get(\"foo\");\n     *  ```\n     */\n    get<Key extends keyof T>(key: Key): T[Key];\n    /**\n     * Set the key with the value.\n     *\n     *  If the value of the key is exist, the old value will be updated.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  map.set(\"foo\", \"baz\");\n     *  ```\n     */\n    set<Key extends keyof T>(key: Key, value: Exclude<T[Key], Container>): void;\n    delete(key: string): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroText {\n    new (): LoroText;\n    insert(pos: number, text: string): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTree<\n    T extends Record<string, unknown> = Record<string, unknown>,\n  > {\n    new (): LoroTree<T>;\n    createNode(parent: TreeID | undefined): LoroTreeNode<T>;\n    move(target: TreeID, parent: TreeID | undefined): void;\n    delete(target: TreeID): void;\n    has(target: TreeID): boolean;\n    getNodeByID(target: TreeID): LoroTreeNode;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTreeNode<\n    T extends Record<string, unknown> = Record<string, unknown>,\n  > {\n    /**\n     * Get the associated metadata map container of a tree node.\n     */\n    readonly data: LoroMap<T>;\n    createNode(): LoroTreeNode<T>;\n    setAsRoot(): void;\n    moveTo(parent: LoroTreeNode<T>): void;\n    parent(): LoroTreeNode<T> | undefined;\n    children(): Array<LoroTreeNode<T>>;\n  }\n}\n\ntype NonNullableType<T> = Exclude<T, null | undefined>;\n"],"names":[],"mappings":";;;;AAkGA,MAAM,eAAkB,GAAA,CAAC,KAAO,EAAA,MAAA,EAAQ,QAAQ,MAAM,CAAA,CAAA;AAE/C,SAAS,cAAc,CAA6B,EAAA;AACzD,EAAO,OAAA,CAAA,CAAE,WAAW,MAAM,CAAA,CAAA;AAC5B,CAAA;AAoBO,SAAS,YAAY,KAAgC,EAAA;AAC1D,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,KAAA,IAAS,IAAM,EAAA;AAC9C,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAM,MAAA,CAAA,GAAI,MAAO,CAAA,cAAA,CAAe,KAAK,CAAA,CAAA;AACrC,EAAI,IAAA,CAAA,IAAK,QAAQ,OAAO,CAAA,KAAM,YAAY,OAAO,CAAA,CAAE,MAAM,CAAA,KAAM,UAAY,EAAA;AACzE,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAA,OAAO,eAAgB,CAAA,QAAA,CAAS,KAAM,CAAA,IAAA,EAAM,CAAA,CAAA;AAC9C,CAAA;AAmBO,SAAS,QACd,KAKS,EAAA;AACT,EAAI,IAAA,WAAA,CAAY,KAAK,CAAG,EAAA;AACtB,IAAA,OAAO,MAAM,IAAK,EAAA,CAAA;AAAA,GACpB;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;;;;;;;;;;;;;"}

package/dist/loro.mjs

@@ -1,35 +1,6 @@
-import { Loro, LoroList, LoroMap } from 'loro-wasm';
 export * from 'loro-wasm';
 export { Loro } from 'loro-wasm';
 
-Loro.prototype.getTypedMap = function(...args) {
-  return this.getMap(...args);
-};
-Loro.prototype.getTypedList = function(...args) {
-  return this.getList(...args);
-};
-LoroList.prototype.getTyped = function(loro, index) {
-  const value = this.get(index);
-  if (typeof value === "string" && isContainerId(value)) {
-    return loro.getContainerById(value);
-  } else {
-    return value;
-  }
-};
-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)) {
-    return loro.getContainerById(value);
-  } else {
-    return value;
-  }
-};
-LoroMap.prototype.setTyped = function(...args) {
-  return this.set(...args);
-};
 const CONTAINER_TYPES = ["Map", "Text", "List", "Tree"];
 function isContainerId(s) {
   return s.startsWith("cid:");

package/dist/loro.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"loro.mjs","sources":["../src/index.ts"],"sourcesContent":["export * from \"loro-wasm\";\nimport {\n  Container,\n  ContainerID,\n  Delta,\n  Loro,\n  LoroList,\n  LoroMap,\n  LoroText,\n  LoroTree,\n  LoroTreeNode,\n  OpId,\n  TreeID,\n  Value,\n} from \"loro-wasm\";\n\nLoro.prototype.getTypedMap = function (...args) {\n  return this.getMap(...args);\n};\nLoro.prototype.getTypedList = function (...args) {\n  return this.getList(...args);\n};\nLoroList.prototype.getTyped = function (loro, index) {\n  const value = this.get(index);\n  if (typeof value === \"string\" && isContainerId(value)) {\n    return loro.getContainerById(value);\n  } else {\n    return value;\n  }\n};\nLoroList.prototype.insertTyped = function (...args) {\n  return this.insert(...args);\n};\nLoroMap.prototype.getTyped = function (loro, key) {\n  const value = this.get(key);\n  if (typeof value === \"string\" && isContainerId(value)) {\n    return loro.getContainerById(value);\n  } else {\n    return value;\n  }\n};\nLoroMap.prototype.setTyped = function (...args) {\n  return this.set(...args);\n};\n\nexport type Frontiers = OpId[];\n\n/**\n * Represents a path to identify the exact location of an event's target.\n * The path is composed of numbers (e.g., indices of a list container) strings\n * (e.g., keys of a map container) and TreeID (the node of a tree container),\n * indicating the absolute position of the event's source within a loro document.\n */\nexport type Path = (number | string | TreeID)[];\n\n/**\n * A batch of events that created by a single `import`/`transaction`/`checkout`.\n *\n * @prop local - Indicates whether the event is local.\n * @prop origin - (Optional) Provides information about the origin of the event.\n * @prop diff - Contains the differential information related to the event.\n * @prop target - Identifies the container ID of the event's target.\n * @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.\n */\nexport interface LoroEventBatch {\n  local: boolean;\n  /**\n   * If true, this event was triggered by a checkout.\n   */\n  fromCheckout: boolean;\n  origin?: string;\n  /**\n   * The container ID of the current event receiver.\n   * It's undefined if the subscriber is on the root document.\n   */\n  currentTarget?: ContainerID;\n  events: LoroEvent[];\n}\n\n/**\n * The concrete event of Loro.\n */\nexport interface LoroEvent {\n  /**\n   * The container ID of the event's target.\n   */\n  target: ContainerID;\n  diff: Diff;\n  /**\n   * The absolute path of the event's emitter, which can be an index of a list container or a key of a map container.\n   */\n  path: Path;\n}\n\nexport type ListDiff = {\n  type: \"list\";\n  diff: Delta<(Value | Container)[]>[];\n};\n\nexport type TextDiff = {\n  type: \"text\";\n  diff: Delta<string>[];\n};\n\nexport type MapDiff = {\n  type: \"map\";\n  updated: Record<string, Value | Container | undefined>;\n};\n\nexport type TreeDiffItem =\n  | { target: TreeID; action: \"create\"; parent: TreeID | undefined }\n  | { target: TreeID; action: \"delete\" }\n  | { target: TreeID; action: \"move\"; parent: TreeID | undefined };\n\nexport type TreeDiff = {\n  type: \"tree\";\n  diff: TreeDiffItem[];\n};\n\nexport type Diff = ListDiff | TextDiff | MapDiff | TreeDiff;\n\ninterface Listener {\n  (event: LoroEventBatch): void;\n}\n\nconst CONTAINER_TYPES = [\"Map\", \"Text\", \"List\", \"Tree\"];\n\nexport function isContainerId(s: string): s is ContainerID {\n  return s.startsWith(\"cid:\");\n}\n\nexport { Loro };\n\n/**  Whether the value is a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * isContainer(map); // true\n * isContainer(list); // true\n * isContainer(text); // true\n * isContainer(123); // false\n * isContainer(\"123\"); // false\n * isContainer({}); // false\n */\nexport function isContainer(value: any): value is Container {\n  if (typeof value !== \"object\" || value == null) {\n    return false;\n  }\n\n  const p = Object.getPrototypeOf(value);\n  if (p == null || typeof p !== \"object\" || typeof p[\"kind\"] !== \"function\") {\n    return false;\n  }\n\n  return CONTAINER_TYPES.includes(value.kind());\n}\n\n/**  Get the type of a value that may be a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * getType(map); // \"Map\"\n * getType(list); // \"List\"\n * getType(text); // \"Text\"\n * getType(123); // \"Json\"\n * getType(\"123\"); // \"Json\"\n * getType({}); // \"Json\"\n * ```\n */\nexport function getType<T>(\n  value: T,\n): T extends LoroText ? \"Text\"\n  : T extends LoroMap ? \"Map\"\n  : T extends LoroTree ? \"Tree\"\n  : T extends LoroList ? \"List\"\n  : \"Json\" {\n  if (isContainer(value)) {\n    return value.kind();\n  }\n\n  return \"Json\" as any;\n}\n\ndeclare module \"loro-wasm\" {\n  interface Loro {\n    subscribe(listener: Listener): number;\n  }\n\n  interface Loro<T extends Record<string, any> = Record<string, any>> {\n    getTypedMap<Key extends keyof T & string>(\n      name: Key,\n    ): T[Key] extends LoroMap ? T[Key] : never;\n    getTypedList<Key extends keyof T & string>(\n      name: Key,\n    ): T[Key] extends LoroList ? T[Key] : never;\n  }\n\n  interface LoroList<T extends any[] = any[]> {\n    insertContainer<C extends Container>(pos: number, child: C): C;\n\n    get(index: number): undefined | Value | Container;\n    getTyped<Key extends keyof T & number>(loro: Loro, index: Key): T[Key];\n    insertTyped<Key extends keyof T & number>(pos: Key, value: T[Key]): void;\n    insert(pos: number, value: Container): never;\n    insert(pos: number, value: Value): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroMap<T extends Record<string, any> = Record<string, any>> {\n    getOrCreateContainer(key: string, container_type: \"Map\"): LoroMap;\n    getOrCreateContainer(key: string, container_type: \"List\"): LoroList;\n    getOrCreateContainer(key: string, container_type: \"Text\"): LoroText;\n    getOrCreateContainer(key: string, container_type: \"Tree\"): LoroTree;\n    getOrCreateContainer(key: string, container_type: string): never;\n\n    setContainer<C extends Container>(key: string, child: C): C;\n\n    get(key: string): undefined | Value | Container;\n    getTyped<Key extends keyof T & string>(txn: Loro, key: Key): T[Key];\n    set(key: string, value: Value): void;\n    setTyped<Key extends keyof T & string>(key: Key, value: T[Key]): void;\n    delete(key: string): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroText {\n    insert(pos: number, text: string): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTree {\n    createNode(parent: TreeID | undefined): LoroTreeNode;\n    move(target: TreeID, parent: TreeID | undefined): void;\n    delete(target: TreeID): void;\n    has(target: TreeID): boolean;\n    getNodeByID(target: TreeID): LoroTreeNode;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTreeNode {\n    readonly data: LoroMap;\n    createNode(): LoroTreeNode;\n    setAsRoot(): void;\n    moveTo(parent: LoroTreeNode): void;\n    parent(): LoroTreeNode | undefined;\n    children(): Array<LoroTreeNode>;\n  }\n}\n"],"names":[],"mappings":";;;;AAgBA,IAAK,CAAA,SAAA,CAAU,WAAc,GAAA,SAAA,GAAa,IAAM,EAAA;AAC9C,EAAO,OAAA,IAAA,CAAK,MAAO,CAAA,GAAG,IAAI,CAAA,CAAA;AAC5B,CAAA,CAAA;AACA,IAAK,CAAA,SAAA,CAAU,YAAe,GAAA,SAAA,GAAa,IAAM,EAAA;AAC/C,EAAO,OAAA,IAAA,CAAK,OAAQ,CAAA,GAAG,IAAI,CAAA,CAAA;AAC7B,CAAA,CAAA;AACA,QAAA,CAAS,SAAU,CAAA,QAAA,GAAW,SAAU,IAAA,EAAM,KAAO,EAAA;AACnD,EAAM,MAAA,KAAA,GAAQ,IAAK,CAAA,GAAA,CAAI,KAAK,CAAA,CAAA;AAC5B,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,aAAA,CAAc,KAAK,CAAG,EAAA;AACrD,IAAO,OAAA,IAAA,CAAK,iBAAiB,KAAK,CAAA,CAAA;AAAA,GAC7B,MAAA;AACL,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AACF,CAAA,CAAA;AACA,QAAS,CAAA,SAAA,CAAU,WAAc,GAAA,SAAA,GAAa,IAAM,EAAA;AAClD,EAAO,OAAA,IAAA,CAAK,MAAO,CAAA,GAAG,IAAI,CAAA,CAAA;AAC5B,CAAA,CAAA;AACA,OAAA,CAAQ,SAAU,CAAA,QAAA,GAAW,SAAU,IAAA,EAAM,GAAK,EAAA;AAChD,EAAM,MAAA,KAAA,GAAQ,IAAK,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC1B,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,aAAA,CAAc,KAAK,CAAG,EAAA;AACrD,IAAO,OAAA,IAAA,CAAK,iBAAiB,KAAK,CAAA,CAAA;AAAA,GAC7B,MAAA;AACL,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AACF,CAAA,CAAA;AACA,OAAQ,CAAA,SAAA,CAAU,QAAW,GAAA,SAAA,GAAa,IAAM,EAAA;AAC9C,EAAO,OAAA,IAAA,CAAK,GAAI,CAAA,GAAG,IAAI,CAAA,CAAA;AACzB,CAAA,CAAA;AAkFA,MAAM,eAAkB,GAAA,CAAC,KAAO,EAAA,MAAA,EAAQ,QAAQ,MAAM,CAAA,CAAA;AAE/C,SAAS,cAAc,CAA6B,EAAA;AACzD,EAAO,OAAA,CAAA,CAAE,WAAW,MAAM,CAAA,CAAA;AAC5B,CAAA;AAoBO,SAAS,YAAY,KAAgC,EAAA;AAC1D,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,KAAA,IAAS,IAAM,EAAA;AAC9C,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAM,MAAA,CAAA,GAAI,MAAO,CAAA,cAAA,CAAe,KAAK,CAAA,CAAA;AACrC,EAAI,IAAA,CAAA,IAAK,QAAQ,OAAO,CAAA,KAAM,YAAY,OAAO,CAAA,CAAE,MAAM,CAAA,KAAM,UAAY,EAAA;AACzE,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAA,OAAO,eAAgB,CAAA,QAAA,CAAS,KAAM,CAAA,IAAA,EAAM,CAAA,CAAA;AAC9C,CAAA;AAmBO,SAAS,QACd,KAKS,EAAA;AACT,EAAI,IAAA,WAAA,CAAY,KAAK,CAAG,EAAA;AACtB,IAAA,OAAO,MAAM,IAAK,EAAA,CAAA;AAAA,GACpB;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}
+{"version":3,"file":"loro.mjs","sources":["../src/index.ts"],"sourcesContent":["export * from \"loro-wasm\";\nimport {\n  Container,\n  ContainerID,\n  Delta,\n  Loro,\n  LoroList,\n  LoroMap,\n  LoroText,\n  LoroTree,\n  OpId,\n  TreeID,\n  Value,\n} from \"loro-wasm\";\n\nexport type Frontiers = OpId[];\n\n/**\n * Represents a path to identify the exact location of an event's target.\n * The path is composed of numbers (e.g., indices of a list container) strings\n * (e.g., keys of a map container) and TreeID (the node of a tree container),\n * indicating the absolute position of the event's source within a loro document.\n */\nexport type Path = (number | string | TreeID)[];\n\n/**\n * A batch of events that created by a single `import`/`transaction`/`checkout`.\n *\n * @prop by - How the event is triggered.\n * @prop origin - (Optional) Provides information about the origin of the event.\n * @prop diff - Contains the differential information related to the event.\n * @prop target - Identifies the container ID of the event's target.\n * @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.\n */\nexport interface LoroEventBatch {\n  /**\n   * How the event is triggered.\n   *\n   * - `local`: The event is triggered by a local transaction.\n   * - `import`: The event is triggered by an import operation.\n   * - `checkout`: The event is triggered by a checkout operation.\n   */\n  by: \"local\" | \"import\" | \"checkout\";\n  origin?: string;\n  /**\n   * The container ID of the current event receiver.\n   * It's undefined if the subscriber is on the root document.\n   */\n  currentTarget?: ContainerID;\n  events: LoroEvent[];\n}\n\n/**\n * The concrete event of Loro.\n */\nexport interface LoroEvent {\n  /**\n   * The container ID of the event's target.\n   */\n  target: ContainerID;\n  diff: Diff;\n  /**\n   * The absolute path of the event's emitter, which can be an index of a list container or a key of a map container.\n   */\n  path: Path;\n}\n\nexport type ListDiff = {\n  type: \"list\";\n  diff: Delta<(Value | Container)[]>[];\n};\n\nexport type TextDiff = {\n  type: \"text\";\n  diff: Delta<string>[];\n};\n\nexport type MapDiff = {\n  type: \"map\";\n  updated: Record<string, Value | Container | undefined>;\n};\n\nexport type TreeDiffItem =\n  | { target: TreeID; action: \"create\"; parent: TreeID | undefined }\n  | { target: TreeID; action: \"delete\" }\n  | { target: TreeID; action: \"move\"; parent: TreeID | undefined };\n\nexport type TreeDiff = {\n  type: \"tree\";\n  diff: TreeDiffItem[];\n};\n\nexport type Diff = ListDiff | TextDiff | MapDiff | TreeDiff;\n\ninterface Listener {\n  (event: LoroEventBatch): void;\n}\n\nconst CONTAINER_TYPES = [\"Map\", \"Text\", \"List\", \"Tree\"];\n\nexport function isContainerId(s: string): s is ContainerID {\n  return s.startsWith(\"cid:\");\n}\n\nexport { Loro };\n\n/**  Whether the value is a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * isContainer(map); // true\n * isContainer(list); // true\n * isContainer(text); // true\n * isContainer(123); // false\n * isContainer(\"123\"); // false\n * isContainer({}); // false\n */\nexport function isContainer(value: any): value is Container {\n  if (typeof value !== \"object\" || value == null) {\n    return false;\n  }\n\n  const p = Object.getPrototypeOf(value);\n  if (p == null || typeof p !== \"object\" || typeof p[\"kind\"] !== \"function\") {\n    return false;\n  }\n\n  return CONTAINER_TYPES.includes(value.kind());\n}\n\n/**  Get the type of a value that may be a container.\n *\n * # Example\n *\n * ```ts\n * const doc = new Loro();\n * const map = doc.getMap(\"map\");\n * const list = doc.getList(\"list\");\n * const text = doc.getText(\"text\");\n * getType(map); // \"Map\"\n * getType(list); // \"List\"\n * getType(text); // \"Text\"\n * getType(123); // \"Json\"\n * getType(\"123\"); // \"Json\"\n * getType({}); // \"Json\"\n * ```\n */\nexport function getType<T>(\n  value: T,\n): T extends LoroText ? \"Text\"\n  : T extends LoroMap<any> ? \"Map\"\n  : T extends LoroTree<any> ? \"Tree\"\n  : T extends LoroList<any> ? \"List\"\n  : \"Json\" {\n  if (isContainer(value)) {\n    return value.kind() as unknown as any;\n  }\n\n  return \"Json\" as any;\n}\n\ndeclare module \"loro-wasm\" {\n  interface Loro {\n    subscribe(listener: Listener): number;\n  }\n\n  interface Loro<\n    T extends Record<string, Container> = Record<string, Container>,\n  > {\n    /**\n     * Get a LoroMap by container id\n     *\n     * The object returned is a new js object each time because it need to cross\n     * the WASM boundary.\n     *\n     * @example\n     * ```ts\n     * import { Loro } from \"loro-crdt\";\n     *\n     * const doc = new Loro();\n     * const map = doc.getMap(\"map\");\n     * ```\n     */\n    getMap<Key extends keyof T>(\n      name: Key,\n    ): T[Key] extends LoroMap ? T[Key] : LoroMap;\n    /**\n     * Get a LoroList by container id\n     *\n     * The object returned is a new js object each time because it need to cross\n     * the WASM boundary.\n     *\n     * @example\n     * ```ts\n     * import { Loro } from \"loro-crdt\";\n     *\n     * const doc = new Loro();\n     * const list = doc.getList(\"list\");\n     * ```\n     */\n    getList<Key extends keyof T>(\n      name: Key,\n    ): T[Key] extends LoroList ? T[Key] : LoroList;\n    /**\n     * Get a LoroTree by container id\n     *\n     *  The object returned is a new js object each time because it need to cross\n     *  the WASM boundary.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const tree = doc.getTree(\"tree\");\n     *  ```\n     */\n    getTree<Key extends keyof T>(\n      name: Key,\n    ): T[Key] extends LoroTree ? T[Key] : LoroTree;\n    getText(key: string | ContainerID): LoroText;\n  }\n\n  interface LoroList<T = unknown> {\n    new (): LoroList<T>;\n    /**\n     *  Get elements of the list. If the value is a child container, the corresponding\n     *  `Container` will be returned.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  list.insert(1, \"foo\");\n     *  list.insert(2, true);\n     *  list.insertContainer(3, new LoroText());\n     *  console.log(list.value);  // [100, \"foo\", true, LoroText];\n     *  ```\n     */\n    toArray(): T[];\n    /**\n     * Insert a container at the index.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  const text = list.insertContainer(1, new LoroText());\n     *  text.insert(0, \"Hello\");\n     *  console.log(list.getDeepValue());  // [100, \"Hello\"];\n     *  ```\n     */\n    insertContainer<C extends Container>(\n      pos: number,\n      child: C,\n    ): T extends C ? T : C;\n    /**\n     * Get the value at the index. If the value is a container, the corresponding handler will be returned.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  console.log(list.get(0));  // 100\n     *  console.log(list.get(1));  // undefined\n     *  ```\n     */\n    get(index: number): T;\n    /**\n     *  Insert a value at index.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const list = doc.getList(\"list\");\n     *  list.insert(0, 100);\n     *  list.insert(1, \"foo\");\n     *  list.insert(2, true);\n     *  console.log(list.value);  // [100, \"foo\", true];\n     *  ```\n     */\n    insert(pos: number, value: Exclude<T, Container>): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n    getAttached(): undefined | LoroList<T>;\n  }\n\n  interface LoroMap<\n    T extends Record<string, unknown> = Record<string, unknown>,\n  > {\n    new (): LoroMap<T>;\n    /**\n     *  Get the value of the key. If the value is a child container, the corresponding\n     *  `Container` will be returned.\n     *\n     *  The object returned is a new js object each time because it need to cross\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  const bar = map.get(\"foo\");\n     *  ```\n     */\n    getOrCreateContainer<C extends Container>(key: string, child: C): C;\n    /**\n     * Set the key with a container.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  const text = map.setContainer(\"text\", new LoroText());\n     *  const list = map.setContainer(\"list\", new LoroText());\n     *  ```\n     */\n    setContainer<C extends Container, Key extends keyof T>(\n      key: Key,\n      child: C,\n    ): NonNullableType<T[Key]> extends C ? NonNullableType<T[Key]> : C;\n    /**\n     *  Get the value of the key. If the value is a child container, the corresponding\n     *  `Container` will be returned.\n     *\n     *  The object/value returned is a new js object/value each time because it need to cross\n     *  the WASM boundary.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  const bar = map.get(\"foo\");\n     *  ```\n     */\n    get<Key extends keyof T>(key: Key): T[Key];\n    /**\n     * Set the key with the value.\n     *\n     *  If the value of the key is exist, the old value will be updated.\n     *\n     *  @example\n     *  ```ts\n     *  import { Loro } from \"loro-crdt\";\n     *\n     *  const doc = new Loro();\n     *  const map = doc.getMap(\"map\");\n     *  map.set(\"foo\", \"bar\");\n     *  map.set(\"foo\", \"baz\");\n     *  ```\n     */\n    set<Key extends keyof T>(key: Key, value: Exclude<T[Key], Container>): void;\n    delete(key: string): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroText {\n    new (): LoroText;\n    insert(pos: number, text: string): void;\n    delete(pos: number, len: number): void;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTree<\n    T extends Record<string, unknown> = Record<string, unknown>,\n  > {\n    new (): LoroTree<T>;\n    createNode(parent: TreeID | undefined): LoroTreeNode<T>;\n    move(target: TreeID, parent: TreeID | undefined): void;\n    delete(target: TreeID): void;\n    has(target: TreeID): boolean;\n    getNodeByID(target: TreeID): LoroTreeNode;\n    subscribe(txn: Loro, listener: Listener): number;\n  }\n\n  interface LoroTreeNode<\n    T extends Record<string, unknown> = Record<string, unknown>,\n  > {\n    /**\n     * Get the associated metadata map container of a tree node.\n     */\n    readonly data: LoroMap<T>;\n    createNode(): LoroTreeNode<T>;\n    setAsRoot(): void;\n    moveTo(parent: LoroTreeNode<T>): void;\n    parent(): LoroTreeNode<T> | undefined;\n    children(): Array<LoroTreeNode<T>>;\n  }\n}\n\ntype NonNullableType<T> = Exclude<T, null | undefined>;\n"],"names":[],"mappings":";;;AAkGA,MAAM,eAAkB,GAAA,CAAC,KAAO,EAAA,MAAA,EAAQ,QAAQ,MAAM,CAAA,CAAA;AAE/C,SAAS,cAAc,CAA6B,EAAA;AACzD,EAAO,OAAA,CAAA,CAAE,WAAW,MAAM,CAAA,CAAA;AAC5B,CAAA;AAoBO,SAAS,YAAY,KAAgC,EAAA;AAC1D,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,KAAA,IAAS,IAAM,EAAA;AAC9C,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAM,MAAA,CAAA,GAAI,MAAO,CAAA,cAAA,CAAe,KAAK,CAAA,CAAA;AACrC,EAAI,IAAA,CAAA,IAAK,QAAQ,OAAO,CAAA,KAAM,YAAY,OAAO,CAAA,CAAE,MAAM,CAAA,KAAM,UAAY,EAAA;AACzE,IAAO,OAAA,KAAA,CAAA;AAAA,GACT;AAEA,EAAA,OAAO,eAAgB,CAAA,QAAA,CAAS,KAAM,CAAA,IAAA,EAAM,CAAA,CAAA;AAC9C,CAAA;AAmBO,SAAS,QACd,KAKS,EAAA;AACT,EAAI,IAAA,WAAA,CAAY,KAAK,CAAG,EAAA;AACtB,IAAA,OAAO,MAAM,IAAK,EAAA,CAAA;AAAA,GACpB;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}

package/dist/src/index.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getType = exports.isContainer = exports.Loro = exports.isContainerId = void 0;
+__exportStar(require("loro-wasm"), exports);
+const loro_wasm_1 = require("loro-wasm");
+Object.defineProperty(exports, "Loro", { enumerable: true, get: function () { return loro_wasm_1.Loro; } });
+loro_wasm_1.Loro.prototype.getTypedMap = function (...args) {
+    return this.getMap(...args);
+};
+loro_wasm_1.Loro.prototype.getTypedList = function (...args) {
+    return this.getList(...args);
+};
+loro_wasm_1.LoroList.prototype.getTyped = function (loro, index) {
+    const value = this.get(index);
+    if (typeof value === "string" && isContainerId(value)) {
+        return loro.getContainerById(value);
+    }
+    else {
+        return value;
+    }
+};
+loro_wasm_1.LoroList.prototype.insertTyped = function (...args) {
+    return this.insert(...args);
+};
+loro_wasm_1.LoroMap.prototype.getTyped = function (loro, key) {
+    const value = this.get(key);
+    if (typeof value === "string" && isContainerId(value)) {
+        return loro.getContainerById(value);
+    }
+    else {
+        return value;
+    }
+};
+loro_wasm_1.LoroMap.prototype.setTyped = function (...args) {
+    return this.set(...args);
+};
+const CONTAINER_TYPES = ["Map", "Text", "List", "Tree"];
+function isContainerId(s) {
+    return s.startsWith("cid:");
+}
+exports.isContainerId = isContainerId;
+/**  Whether the value is a container.
+ *
+ * # Example
+ *
+ * ```ts
+ * const doc = new Loro();
+ * const map = doc.getMap("map");
+ * const list = doc.getList("list");
+ * const text = doc.getText("text");
+ * isContainer(map); // true
+ * isContainer(list); // true
+ * isContainer(text); // true
+ * isContainer(123); // false
+ * isContainer("123"); // false
+ * isContainer({}); // false
+ */
+function isContainer(value) {
+    if (typeof value !== "object" || value == null) {
+        return false;
+    }
+    const p = Object.getPrototypeOf(value);
+    if (p == null || typeof p !== "object" || typeof p["kind"] !== "function") {
+        return false;
+    }
+    return CONTAINER_TYPES.includes(value.kind());
+}
+exports.isContainer = isContainer;
+/**  Get the type of a value that may be a container.
+ *
+ * # Example
+ *
+ * ```ts
+ * const doc = new Loro();
+ * const map = doc.getMap("map");
+ * const list = doc.getList("list");
+ * const text = doc.getText("text");
+ * getType(map); // "Map"
+ * getType(list); // "List"
+ * getType(text); // "Text"
+ * getType(123); // "Json"
+ * getType("123"); // "Json"
+ * getType({}); // "Json"
+ * ```
+ */
+function getType(value) {
+    if (isContainer(value)) {
+        return value.kind();
+    }
+    return "Json";
+}
+exports.getType = getType;