loro-crdt 0.2.7 → 0.2.8-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loro-crdt",
-  "version": "0.2.7",
+  "version": "0.2.8-alpha",
   "description": "",
   "main": "dist/loro.js",
   "module": "dist/loro.mjs",

package/src/index.ts

@@ -33,6 +33,27 @@ Loro.prototype.transact = function (cb, origin) {
   });
 };
 
+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)) {
+    return loro.getContainerById(value);
+  } else {
+    return value;
+  }
+};
+LoroList.prototype.insertTyped = LoroList.prototype.insert;
+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 = LoroMap.prototype.set;
+
 LoroText.prototype.insert = function (txn, pos, text) {
   if (txn instanceof Loro) {
     this.__loro_insert(txn, pos, text);
@@ -173,7 +194,16 @@ declare module "loro-wasm" {
     transact(f: (tx: Transaction) => void, origin?: string): void;
   }
 
-  interface LoroList {
+  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 LoroList<T extends any[] = any[]> {
     insertContainer(
       txn: Transaction | Loro,
       pos: number,
@@ -196,6 +226,12 @@ declare module "loro-wasm" {
     ): 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;
@@ -203,7 +239,7 @@ declare module "loro-wasm" {
     subscribeOnce(txn: Transaction | Loro, listener: Listener): number;
   }
 
-  interface LoroMap {
+  interface LoroMap<T extends Record<string, any> = Record<string, any>> {
     insertContainer(
       txn: Transaction | Loro,
       key: string,
@@ -226,7 +262,16 @@ declare module "loro-wasm" {
     ): 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;

package/tests/misc.test.ts

@@ -1,9 +1,10 @@
-import { describe, expect, it } from "vitest";
+import { assertType, describe, expect, it } from "vitest";
 import {
   Delta,
   ListDiff,
   Loro,
   LoroEvent,
+  LoroList,
   LoroMap,
   MapDiff as MapDiff,
   PrelimList,
@@ -12,6 +13,7 @@ import {
   TextDiff,
   Transaction,
 } from "../src";
+import { expectTypeOf } from "vitest";
 
 function assertEquals(a: any, b: any) {
   expect(a).toStrictEqual(b);
@@ -257,6 +259,35 @@ describe("wasm", () => {
   });
 });
 
+describe("type", () => {
+  it("test map type", () => {
+    const loro = new Loro<{ map: LoroMap<{ name: "he" }> }>();
+    const map = loro.getTypedMap("map");
+    const v = map.getTyped(loro, "name");
+    expectTypeOf(v).toEqualTypeOf<"he">();
+  });
+
+  it("test recursive map type", () => {
+    const loro = new Loro<{ map: LoroMap<{ map: LoroMap<{ name: "he" }> }> }>();
+    const map = loro.getTypedMap("map");
+    map.insertContainer(loro, "map", "Map");
+    const subMap = map.getTyped(loro, "map");
+    const name = subMap.getTyped(loro, "name");
+    expectTypeOf(name).toEqualTypeOf<"he">();
+  });
+
+  it("works for list type", () => {
+    const loro = new Loro<{ list: LoroList<[string, number]> }>();
+    const list = loro.getTypedList("list");
+    list.insertTyped(loro, 0, "123");
+    list.insertTyped(loro, 1, 123);
+    const v0 = list.getTyped(loro, 0);
+    expectTypeOf(v0).toEqualTypeOf<string>();
+    const v1 = list.getTyped(loro, 1);
+    expectTypeOf(v1).toEqualTypeOf<number>();
+  });
+});
+
 function one_ms(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 1));
 }