jazz-tools 0.8.14 → 0.8.16

package/src/tests/groupsAndAccounts.test.ts

@@ -1,91 +1,87 @@
-import { expect, describe, test } from "vitest";
-import { Account, CoMap, co, Group, WasmCrypto } from "../index.web.js";
+import { describe, expect, test } from "vitest";
+import { Account, CoMap, Group, WasmCrypto, co } from "../index.web.js";
 
 const Crypto = await WasmCrypto.create();
 
 describe("Custom accounts and groups", async () => {
-    class CustomProfile extends CoMap {
-        name = co.string;
-        color = co.string;
+  class CustomProfile extends CoMap {
+    name = co.string;
+    color = co.string;
+  }
+
+  class CustomAccount extends Account {
+    profile = co.ref(CustomProfile);
+    root = co.ref(CoMap);
+
+    migrate(this: CustomAccount, creationProps?: { name: string }) {
+      if (creationProps) {
+        const profileGroup = Group.create({ owner: this });
+        profileGroup.addMember("everyone", "reader");
+        this.profile = CustomProfile.create(
+          { name: creationProps.name, color: "blue" },
+          { owner: this },
+        );
+      }
     }
+  }
 
-    class CustomAccount extends Account {
-        profile = co.ref(CustomProfile);
-        root = co.ref(CoMap);
-
-        migrate(this: CustomAccount, creationProps?: { name: string }) {
-            if (creationProps) {
-                const profileGroup = Group.create({ owner: this });
-                profileGroup.addMember("everyone", "reader");
-                this.profile = CustomProfile.create(
-                    { name: creationProps.name, color: "blue" },
-                    { owner: this },
-                );
-            }
-        }
+  class CustomGroup extends Group {
+    profile = co.null;
+    root = co.null;
+    [co.members] = co.ref(CustomAccount);
+
+    get nMembers() {
+      return this.members.length;
     }
+  }
 
-    class CustomGroup extends Group {
-        profile = co.null;
-        root = co.null;
-        [co.members] = co.ref(CustomAccount);
+  test("Custom account and group", async () => {
+    const me = await CustomAccount.create({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
+    });
 
-        get nMembers() {
-            return this.members.length;
-        }
-    }
+    expect(me.profile).toBeDefined();
+    expect(me.profile?.name).toBe("Hermes Puggington");
+    expect(me.profile?.color).toBe("blue");
 
-    test("Custom account and group", async () => {
-        const me = await CustomAccount.create({
-            creationProps: { name: "Hermes Puggington" },
-            crypto: Crypto,
-        });
+    const group = new CustomGroup({ owner: me });
+    group.addMember("everyone", "reader");
 
-        expect(me.profile).toBeDefined();
-        expect(me.profile?.name).toBe("Hermes Puggington");
-        expect(me.profile?.color).toBe("blue");
-
-        const group = new CustomGroup({ owner: me });
-        group.addMember("everyone", "reader");
-
-        expect(group.members).toMatchObject([
-            { id: me.id, role: "admin" },
-            { id: "everyone", role: "reader" },
-        ]);
-
-        expect(group.nMembers).toBe(2);
-
-        await new Promise<void>((resolve) => {
-            group.subscribe({}, (update) => {
-                const meAsMember = update.members.find((member) => {
-                    return member.id === me.id && member.account?.profile;
-                });
-                if (meAsMember) {
-                    expect(meAsMember.account?.profile?.name).toBe(
-                        "Hermes Puggington",
-                    );
-                    expect(meAsMember.account?.profile?.color).toBe("blue");
-                    resolve();
-                }
-            });
-        });
+    expect(group.members).toMatchObject([
+      { id: me.id, role: "admin" },
+      { id: "everyone", role: "reader" },
+    ]);
 
-        class MyMap extends CoMap {
-            name = co.string;
+    expect(group.nMembers).toBe(2);
+
+    await new Promise<void>((resolve) => {
+      group.subscribe({}, (update) => {
+        const meAsMember = update.members.find((member) => {
+          return member.id === me.id && member.account?.profile;
+        });
+        if (meAsMember) {
+          expect(meAsMember.account?.profile?.name).toBe("Hermes Puggington");
+          expect(meAsMember.account?.profile?.color).toBe("blue");
+          resolve();
         }
+      });
+    });
 
-        const map = MyMap.create({ name: "test" }, { owner: group });
+    class MyMap extends CoMap {
+      name = co.string;
+    }
 
-        const meAsCastMember = map._owner
-            .castAs(CustomGroup)
-            .members.find((member) => member.id === me.id);
-        expect(meAsCastMember?.account?.profile?.name).toBe(
-            "Hermes Puggington",
-        );
-        expect(meAsCastMember?.account?.profile?.color).toBe("blue");
+    const map = MyMap.create({ name: "test" }, { owner: group });
 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        expect((map._owner as any).nMembers).toBeUndefined();
-        expect(map._owner.castAs(CustomGroup).nMembers).toBe(2);
-    });
+    const meAsCastMember = map._owner
+      .castAs(CustomGroup)
+      .members.find((member) => member.id === me.id);
+    expect(meAsCastMember?.account?.profile?.name).toBe("Hermes Puggington");
+    expect(meAsCastMember?.account?.profile?.color).toBe("blue");
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect((map._owner as any).nMembers).toBeUndefined();
+    expect(map._owner.castAs(CustomGroup).nMembers).toBe(2);
+  });
 });

package/src/tests/schema.test.ts

@@ -3,203 +3,203 @@ import { CoMap, co } from "../index.web.js";
 import { co as valueWithCoMarker } from "../internal.js";
 
 describe("co.json TypeScript validation", () => {
-    it("should accept serializable types", async () => {
-        type ValidType = { str: string; num: number; bool: boolean };
-
-        class ValidPrimitiveMap extends CoMap {
-            data = co.json<ValidType>();
-        }
-
-        expectTypeOf(ValidPrimitiveMap.create<ValidPrimitiveMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<ValidType>;
-            }>();
-    });
-
-    it("should accept nested serializable types", async () => {
-        type NestedType = {
-            outer: {
-                inner: {
-                    value: string;
-                };
-            };
-        }
-
-        class ValidNestedMap extends CoMap {
-            data = co.json<NestedType>();
-        }
-
-        expectTypeOf(ValidNestedMap.create<ValidNestedMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<NestedType>;
-            }>();
-    });
-
-    it("should accept types with optional attributes", async () => {
-        type TypeWithOptional = {
-            value: string;
-            optional?: string | null;
-        }
-
-        class ValidMap extends CoMap {
-            data = co.json<TypeWithOptional>();
-        }
-
-        expectTypeOf(ValidMap.create<ValidMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<TypeWithOptional>;
-            }>();
-    });
-
-    it("should accept nested serializable interfaces", async () => {
-        interface InnerInterface {
-            value: string;
-        }
-
-        interface NestedInterface {
-            outer: {
-                inner: InnerInterface;
-            };
-        }
-
-        class ValidNestedMap extends CoMap {
-            data = co.json<NestedInterface>();
-        }
-
-        expectTypeOf(ValidNestedMap.create<ValidNestedMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<NestedInterface>;
-            }>();
-    });
-
-    it("should accept arrays of serializable types", async () => {
-        interface ArrayInterface {
-            numbers: number[];
-            objects: { id: number; name: string }[];
-        }
-
-        class ValidArrayMap extends CoMap {
-            data = co.json<ArrayInterface>();
-        }
-
-        expectTypeOf(ValidArrayMap.create<ValidArrayMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<ArrayInterface>;
-            }>();
-    });
-
-    it("should flag interfaces with functions as invalid", async () => {
-        interface InvalidInterface {
-            func: () => void;
-        }
-
-        class InvalidFunctionMap extends CoMap {
-            // @ts-expect-error Should not be considered valid
-            data = co.json<InvalidInterface>();
-        }
-
-        expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<InvalidInterface>;
-            }>();
-    });
-
-    it("should flag types with functions as invalid", async () => {
-        type InvalidType = { func: () => void };
-
-        class InvalidFunctionMap extends CoMap {
-            // @ts-expect-error Should not be considered valid
-            data = co.json<InvalidType>();
-        }
-
-        expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<InvalidType>;
-            }>();
-    });
-
-    it("should flag types with non-serializable constructors as invalid", async () => {
-        type InvalidType = { date: Date; regexp: RegExp; symbol: symbol };
-
-        class InvalidFunctionMap extends CoMap {
-            // @ts-expect-error Should not be considered valid
-            data = co.json<InvalidType>();
-        }
-
-        expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<InvalidType>;
-            }>();
-    });
-
-    it("should apply the same validation to optional json", async () => {
-        type ValidType = {
-            value: string;
+  it("should accept serializable types", async () => {
+    type ValidType = { str: string; num: number; bool: boolean };
+
+    class ValidPrimitiveMap extends CoMap {
+      data = co.json<ValidType>();
+    }
+
+    expectTypeOf(ValidPrimitiveMap.create<ValidPrimitiveMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<ValidType>;
+      }>();
+  });
+
+  it("should accept nested serializable types", async () => {
+    type NestedType = {
+      outer: {
+        inner: {
+          value: string;
         };
-
-        type InvalidType = {
-            value: () => string;
-        };
-
-        class MapWithOptionalJSON extends CoMap {
-            data = co.optional.json<ValidType>();
-            // @ts-expect-error Should not be considered valid
-            data2 = co.optional.json<InvalidType>();
-        }
-
-        expectTypeOf(MapWithOptionalJSON.create<MapWithOptionalJSON>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data?: valueWithCoMarker<ValidType> | null;
-                data2?: valueWithCoMarker<InvalidType> | null;
-            }>();
-    });
-
-    it("should not accept functions", async () => {
-        class InvalidFunctionMap extends CoMap {
-            // @ts-expect-error Should not be considered valid
-            data = co.json<() => void>();
-        }
-
-        expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<() => void>;
-            }>();
-    });
-
-    it("should not accept RegExp", async () => {
-        class InvalidFunctionMap extends CoMap {
-            // @ts-expect-error Should not be considered valid
-            data = co.json<RegExp>();
-        }
-
-        expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                data: valueWithCoMarker<RegExp>;
-            }>();
-    });
-
-    it("should accept strings and numbers", async () => {
-        class InvalidFunctionMap extends CoMap {
-            str = co.json<string>();
-            num = co.json<number>();
-        }
-
-        expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
-            .parameter(0)
-            .toEqualTypeOf<{
-                str: valueWithCoMarker<string>;
-                num: valueWithCoMarker<number>;
-            }>();
-    });
+      };
+    };
+
+    class ValidNestedMap extends CoMap {
+      data = co.json<NestedType>();
+    }
+
+    expectTypeOf(ValidNestedMap.create<ValidNestedMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<NestedType>;
+      }>();
+  });
+
+  it("should accept types with optional attributes", async () => {
+    type TypeWithOptional = {
+      value: string;
+      optional?: string | null;
+    };
+
+    class ValidMap extends CoMap {
+      data = co.json<TypeWithOptional>();
+    }
+
+    expectTypeOf(ValidMap.create<ValidMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<TypeWithOptional>;
+      }>();
+  });
+
+  it("should accept nested serializable interfaces", async () => {
+    interface InnerInterface {
+      value: string;
+    }
+
+    interface NestedInterface {
+      outer: {
+        inner: InnerInterface;
+      };
+    }
+
+    class ValidNestedMap extends CoMap {
+      data = co.json<NestedInterface>();
+    }
+
+    expectTypeOf(ValidNestedMap.create<ValidNestedMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<NestedInterface>;
+      }>();
+  });
+
+  it("should accept arrays of serializable types", async () => {
+    interface ArrayInterface {
+      numbers: number[];
+      objects: { id: number; name: string }[];
+    }
+
+    class ValidArrayMap extends CoMap {
+      data = co.json<ArrayInterface>();
+    }
+
+    expectTypeOf(ValidArrayMap.create<ValidArrayMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<ArrayInterface>;
+      }>();
+  });
+
+  it("should flag interfaces with functions as invalid", async () => {
+    interface InvalidInterface {
+      func: () => void;
+    }
+
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<InvalidInterface>();
+    }
+
+    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<InvalidInterface>;
+      }>();
+  });
+
+  it("should flag types with functions as invalid", async () => {
+    type InvalidType = { func: () => void };
+
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<InvalidType>();
+    }
+
+    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<InvalidType>;
+      }>();
+  });
+
+  it("should flag types with non-serializable constructors as invalid", async () => {
+    type InvalidType = { date: Date; regexp: RegExp; symbol: symbol };
+
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<InvalidType>();
+    }
+
+    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<InvalidType>;
+      }>();
+  });
+
+  it("should apply the same validation to optional json", async () => {
+    type ValidType = {
+      value: string;
+    };
+
+    type InvalidType = {
+      value: () => string;
+    };
+
+    class MapWithOptionalJSON extends CoMap {
+      data = co.optional.json<ValidType>();
+      // @ts-expect-error Should not be considered valid
+      data2 = co.optional.json<InvalidType>();
+    }
+
+    expectTypeOf(MapWithOptionalJSON.create<MapWithOptionalJSON>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data?: valueWithCoMarker<ValidType> | null;
+        data2?: valueWithCoMarker<InvalidType> | null;
+      }>();
+  });
+
+  it("should not accept functions", async () => {
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<() => void>();
+    }
+
+    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<() => void>;
+      }>();
+  });
+
+  it("should not accept RegExp", async () => {
+    class InvalidFunctionMap extends CoMap {
+      // @ts-expect-error Should not be considered valid
+      data = co.json<RegExp>();
+    }
+
+    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        data: valueWithCoMarker<RegExp>;
+      }>();
+  });
+
+  it("should accept strings and numbers", async () => {
+    class InvalidFunctionMap extends CoMap {
+      str = co.json<string>();
+      num = co.json<number>();
+    }
+
+    expectTypeOf(InvalidFunctionMap.create<InvalidFunctionMap>)
+      .parameter(0)
+      .toEqualTypeOf<{
+        str: valueWithCoMarker<string>;
+        num: valueWithCoMarker<number>;
+      }>();
+  });
 });