jazz-tools 0.7.0-alpha.30 → 0.7.0-alpha.31

package/src/coValues/account.ts

@@ -33,12 +33,7 @@ import {
 } from "../internal.js";
 import type { Stream } from "effect/Stream";
 
-export class Account<
-        Def extends { profile: Profile | null; root: CoMap | null } = {
-            profile: Profile | null;
-            root: CoMap | null;
-        },
-    >
+export class Account
     extends CoValueBase
     implements CoValue<"Account", RawAccount | RawControlledAccount>
 {
@@ -69,23 +64,17 @@ export class Account<
             : Account.fromNode(this._raw.core.node);
     }
 
-    profile!: NonNullable<Def["profile"]> | null;
-    root!: NonNullable<Def["root"]> | null;
+    declare profile: Profile | null;
+    declare root: CoMap | null;
 
-    get _refs(): {
-        profile: NonNullable<Def["profile"]> extends Profile
-            ? Ref<NonNullable<Def["profile"]>> | null
-            : null;
-        root: NonNullable<Def["root"]> extends CoMap
-            ? Ref<NonNullable<Def["root"]>> | null
-            : null;
-    } {
+    get _refs() {
         const profileID = this._raw.get("profile") as unknown as
-            | ID<NonNullable<Def["profile"]>>
+            | ID<NonNullable<this["profile"]>>
             | undefined;
         const rootID = this._raw.get("root") as unknown as
-            | ID<NonNullable<Def["root"]>>
+            | ID<NonNullable<this["root"]>>
             | undefined;
+
         return {
             profile:
                 profileID &&
@@ -93,35 +82,29 @@ export class Account<
                     profileID,
                     this._loadedAs,
                     this._schema.profile as RefEncoded<
-                        NonNullable<Def["profile"]> & CoValue
+                        NonNullable<this["profile"]> & CoValue
                     >
-                ) as any),
+                ) as any as NonNullable<this["profile"]> extends Profile
+                    ? Ref<NonNullable<this["profile"]>> | null
+                    : null),
             root:
                 rootID &&
                 (new Ref(
                     rootID,
                     this._loadedAs,
                     this._schema.root as RefEncoded<
-                        NonNullable<Def["root"]> & CoValue
+                        NonNullable<this["root"]> & CoValue
                     >
-                ) as any),
+                ) as any as NonNullable<this["root"]> extends CoMap
+                    ? Ref<NonNullable<this["root"]>> | null
+                    : null),
         };
     }
 
     isMe: boolean;
     sessionID: SessionID | undefined;
 
-    constructor(init: undefined, options: { owner: Group | Account });
-    constructor(
-        init: undefined,
-        options: { fromRaw: RawAccount | RawControlledAccount }
-    );
-    constructor(
-        _init: undefined,
-        options:
-            | { fromRaw: RawAccount | RawControlledAccount }
-            | { owner: Group | Account }
-    ) {
+    constructor(options: { fromRaw: RawAccount | RawControlledAccount }) {
         super();
         if (!("fromRaw" in options)) {
             throw new Error(
@@ -191,7 +174,7 @@ export class Account<
         const { node } = await LocalNode.withNewlyCreatedAccount({
             ...options,
             migration: async (rawAccount, _node, creationProps) => {
-                const account = new this(undefined, {
+                const account = new this({
                     fromRaw: rawAccount,
                 }) as A & Me;
 
@@ -217,7 +200,7 @@ export class Account<
             sessionID: options.sessionID,
             peersToLoadFrom: options.peersToLoadFrom,
             migration: async (rawAccount, _node, creationProps) => {
-                const account = new this(undefined, {
+                const account = new this({
                     fromRaw: rawAccount,
                 }) as A & Me;
 
@@ -232,7 +215,7 @@ export class Account<
         this: SubclassedConstructor<A>,
         node: LocalNode
     ): A & Me {
-        return new this(undefined, {
+        return new this({
             fromRaw: node.account as RawControlledAccount,
         }) as A & Me;
     }
@@ -250,9 +233,9 @@ export class Account<
 
     migrate(creationProps?: { name: string }): void | Promise<void> {
         if (creationProps) {
-            const profileGroup = new Group({ owner: this });
+            const profileGroup = Group.create({ owner: this });
             profileGroup.addMember("everyone", "reader");
-            this.profile = new Profile(
+            this.profile = Profile.create(
                 { name: creationProps.name },
                 { owner: profileGroup }
             );

package/src/coValues/coList.ts

@@ -11,6 +11,7 @@ import type {
     SubclassedConstructor,
     UnavailableError,
     IfCo,
+    UnCo,
 } from "../internal.js";
 import {
     Account,
@@ -32,6 +33,7 @@ export class CoList<Item = any>
     implements CoValue<"CoList", RawCoList>
 {
     static Of<Item>(item: IfCo<Item, Item>): typeof CoList<Item> {
+        // TODO: cache superclass for item class
         return class CoListOf extends CoList<Item> {
             [co.items] = item;
         };
@@ -107,21 +109,16 @@ export class CoList<Item = any>
         return Array;
     }
 
-    constructor(_init: undefined, options: { fromRaw: RawCoList });
-    constructor(init: Item[], options: { owner: Account | Group });
     constructor(
-        init: Item[] | undefined,
-        options?: { owner: Account | Group } | { fromRaw: RawCoList }
+        options:
+            | { init: Item[]; owner: Account | Group }
+            | { fromRaw: RawCoList }
     ) {
         super();
 
-        if (!options) {
-            throw new Error("Must provide options");
-        }
-
-        if (init && "owner" in options) {
+        if ("owner" in options) {
             this[InitValues] = {
-                init,
+                init: options.init,
                 owner: options.owner,
             };
         } else if ("fromRaw" in options) {
@@ -137,6 +134,14 @@ export class CoList<Item = any>
         return new Proxy(this, CoListProxyHandler as ProxyHandler<this>);
     }
 
+    static create<L extends CoList>(
+        this: SubclassedConstructor<L>,
+        items: UnCo<L[number]>[],
+        options: {owner: Account | Group}
+    ) {
+        return new this({ init: items, owner: options.owner });
+    }
+
     push(...items: Item[]): number;
     /** @private For exact type compatibility with Array superclass */
     push(...items: Item[]): number;
@@ -238,7 +243,7 @@ export class CoList<Item = any>
         this: SubclassedConstructor<V> & typeof CoList,
         raw: RawCoList
     ) {
-        return new this(undefined, { fromRaw: raw });
+        return new this({ fromRaw: raw });
     }
 
     static loadEf = CoValueBase.loadEf as unknown as <V extends CoValue>(

package/src/coValues/coMap.ts

@@ -9,6 +9,7 @@ import type {
     RefEncoded,
     IfCo,
     RefIfCoValue,
+    SubclassedConstructor,
 } from "../internal.js";
 import {
     Account,
@@ -23,11 +24,6 @@ import {
     isRefEncoded,
 } from "../internal.js";
 
-type DefaultFields = {
-    [key: string]: any;
-    [ItemsSym]?: any;
-};
-
 type CoMapEdit<V> = {
     value?: V;
     ref?: RefIfCoValue<V>;
@@ -40,10 +36,7 @@ type InitValuesFor<C extends CoMap> = {
     owner: Account | Group;
 };
 
-export class CoMap<Fields extends object = DefaultFields>
-    extends CoValueBase
-    implements CoValue<"CoMap", RawCoMap>
-{
+export class CoMap extends CoValueBase implements CoValue<"CoMap", RawCoMap> {
     declare id: ID<this>;
     declare _type: "CoMap";
     static {
@@ -130,20 +123,14 @@ export class CoMap<Fields extends object = DefaultFields>
 
     [InitValues]?: any;
 
-    constructor(_init: undefined, options: { fromRaw: RawCoMap });
     constructor(
-        init: Simplify<CoMapInit<Fields>>,
-        options: { owner: Account | Group }
-    );
-    constructor(
-        init: Simplify<CoMapInit<Fields>> | undefined,
-        options: { owner: Account | Group } | { fromRaw: RawCoMap }
+        options: { fromRaw: RawCoMap } | { init: any; owner: Account | Group }
     ) {
         super();
 
-        if (init && "owner" in options) {
+        if ("owner" in options) {
             this[InitValues] = {
-                init,
+                init: options.init,
                 owner: options.owner,
             } as InitValuesFor<this>;
         } else if ("fromRaw" in options) {
@@ -161,6 +148,14 @@ export class CoMap<Fields extends object = DefaultFields>
         return new Proxy(this, CoMapProxyHandler as ProxyHandler<this>);
     }
 
+    static create<M extends CoMap>(
+        this: SubclassedConstructor<M>,
+        init: Simplify<CoMapInit<M>>,
+        options: { owner: Account | Group }
+    ) {
+        return new this({ init, owner: options.owner });
+    }
+
     toJSON() {
         const jsonedFields = this._raw.keys().map((key) => {
             const tKey = key as CoKeys<this>;
@@ -224,7 +219,7 @@ export class CoMap<Fields extends object = DefaultFields>
 
     static Record<Value>(value: IfCo<Value, Value>) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
-        class RecordLikeCoMap extends CoMap<RecordLikeCoMap> {
+        class RecordLikeCoMap extends CoMap {
             [ItemsSym] = value;
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
@@ -236,7 +231,7 @@ export class CoMap<Fields extends object = DefaultFields>
 
 export type CoKeys<Fields extends object> = Exclude<
     keyof Fields & string,
-    keyof CoMap<Record<string, never>>
+    keyof CoMap
 >;
 
 export type CoMapInit<Fields extends object> = {

package/src/coValues/coStream.ts

@@ -17,6 +17,8 @@ import type {
     ID,
     Me,
     IfCo,
+    SubclassedConstructor,
+    UnCo,
 } from "../internal.js";
 import {
     ItemsSym,
@@ -47,9 +49,7 @@ export class CoStream<Item = any>
     extends CoValueBase
     implements CoValue<"CoStream", RawCoStream>
 {
-    static Of<Item>(
-        item: IfCo<Item, Item>
-    ): typeof CoStream<Item> {
+    static Of<Item>(item: IfCo<Item, Item>): typeof CoStream<Item> {
         return class CoStreamOf extends CoStream<Item> {
             [co.items] = item;
         };
@@ -85,11 +85,10 @@ export class CoStream<Item = any>
 
     [InitValues]?: any;
 
-    constructor(_init: undefined, options: { fromRaw: RawCoStream });
-    constructor(init: Item[], options: { owner: Account | Group });
     constructor(
-        init: Item[] | undefined,
-        options: { owner: Account | Group } | { fromRaw: RawCoStream }
+        options:
+            | { init: Item[]; owner: Account | Group }
+            | { fromRaw: RawCoStream }
     ) {
         super();
 
@@ -103,7 +102,7 @@ export class CoStream<Item = any>
             });
         } else {
             this[InitValues] = {
-                init,
+                init: options.init,
                 owner: options.owner,
             };
         }
@@ -111,6 +110,14 @@ export class CoStream<Item = any>
         return new Proxy(this, CoStreamProxyHandler as ProxyHandler<this>);
     }
 
+    static create<S extends CoStream>(
+        this: SubclassedConstructor<S>,
+        init: S extends CoStream<infer Item> ? UnCo<Item>[] : never,
+        options: { owner: Account | Group }
+    ) {
+        return new this({ init, owner: options.owner });
+    }
+
     push(...items: Item[]) {
         for (const item of items) {
             this.pushItem(item);
@@ -123,9 +130,7 @@ export class CoStream<Item = any>
         if (itemDescriptor === "json") {
             this._raw.push(item as JsonValue);
         } else if ("encoded" in itemDescriptor) {
-            this._raw.push(
-                encodeSync(itemDescriptor.encoded)(item)
-            );
+            this._raw.push(encodeSync(itemDescriptor.encoded)(item));
         } else if (isRefEncoded(itemDescriptor)) {
             this._raw.push((item as unknown as CoValue).id);
         }
@@ -192,9 +197,7 @@ function entryFromRawEntry<Item>(
                     ? (CoValue & Item) | null
                     : Item;
             } else if ("encoded" in itemField) {
-                return decodeSync(itemField.encoded)(
-                    rawEntry.value
-                );
+                return decodeSync(itemField.encoded)(rawEntry.value);
             } else if (isRefEncoded(itemField)) {
                 return this.ref?.accessFrom(
                     accessFrom
@@ -292,7 +295,10 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
 
             return entry;
         } else if (key === "perSession") {
-            return new Proxy({}, CoStreamPerSessionProxyHandler(target, receiver));
+            return new Proxy(
+                {},
+                CoStreamPerSessionProxyHandler(target, receiver)
+            );
         } else {
             return Reflect.get(target, key, receiver);
         }
@@ -350,7 +356,10 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
     },
 };
 
-const CoStreamPerSessionProxyHandler = (innerTarget: CoStream, accessFrom: CoStream): ProxyHandler<Record<string, never>> => ({
+const CoStreamPerSessionProxyHandler = (
+    innerTarget: CoStream,
+    accessFrom: CoStream
+): ProxyHandler<Record<string, never>> => ({
     get(_target, key, receiver) {
         if (typeof key === "string" && key.includes("session")) {
             const sessionID = key as SessionID;
@@ -420,7 +429,6 @@ export class BinaryCoStream
     declare _raw: RawBinaryCoStream;
 
     constructor(
-        _init: [] | undefined,
         options:
             | {
                   owner: Account | Group;
@@ -449,6 +457,13 @@ export class BinaryCoStream
         });
     }
 
+    static create<S extends BinaryCoStream>(
+        this: SubclassedConstructor<S>,
+        options: { owner: Account | Group }
+    ) {
+        return new this(options);
+    }
+
     getChunks(options?: {
         allowUnfinished?: boolean;
     }):

package/src/coValues/extensions/imageDef.ts

@@ -5,7 +5,7 @@ import {
     subscriptionsScopes,
 } from "../../internal.js";
 
-export class ImageDefinition extends CoMap<ImageDefinition> {
+export class ImageDefinition extends CoMap {
     originalSize = co.json<[number, number]>();
     placeholderDataURL? = co.string;
 

package/src/coValues/group.ts

@@ -2,9 +2,9 @@ import type { AccountID, Everyone, RawGroup, Role } from "cojson";
 import type {
     CoValue,
     ID,
-    JsonEncoded,
     RefEncoded,
     Schema,
+    SubclassedConstructor,
 } from "../internal.js";
 import {
     Account,
@@ -17,34 +17,11 @@ import {
     MembersSym,
 } from "../internal.js";
 
-export class Profile extends CoMap<{ name: co<string> }> {
+export class Profile extends CoMap {
     name = co.string;
 }
 
-type GroupSchema<Def extends Group> = {
-    profile: NonNullable<Def["profile"]> extends CoValue
-        ? RefEncoded<NonNullable<Def["profile"]>>
-        : JsonEncoded;
-    root: NonNullable<Def["root"]> extends CoValue
-        ? RefEncoded<NonNullable<Def["root"]>>
-        : JsonEncoded;
-    [MembersSym]: RefEncoded<NonNullable<Def[MembersSym]>>;
-};
-
-export class Group<
-        Def extends {
-            profile: Profile | null;
-            root: CoMap | null;
-            [MembersSym]: Account | null;
-        } = {
-            profile: Profile | null;
-            root: CoMap | null;
-            [MembersSym]: Account | null;
-        },
-    >
-    extends CoValueBase
-    implements CoValue<"Group", RawGroup>
-{
+export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
     declare id: ID<this>;
     declare _type: "Group";
     static {
@@ -53,7 +30,11 @@ export class Group<
     declare _raw: RawGroup;
 
     static _schema: any;
-    get _schema(): GroupSchema<this> {
+    get _schema(): {
+        profile: Schema;
+        root: Schema;
+        [MembersSym]: RefEncoded<Account>;
+    } {
         return (this.constructor as typeof Group)._schema;
     }
     static {
@@ -67,19 +48,16 @@ export class Group<
         });
     }
 
-    declare profile: Def["profile"] | null;
-    declare root: Def["root"] | null;
-    declare [MembersSym]: Def[MembersSym] | null;
+    declare profile: Profile | null;
+    declare root: CoMap | null;
+    declare [MembersSym]: Account | null;
 
-    get _refs(): {
-        profile: Def["profile"] extends Profile ? Ref<Def["profile"]> : never;
-        root: Def["root"] extends CoMap ? Ref<Def["root"]> : never;
-    } {
+    get _refs() {
         const profileID = this._raw.get("profile") as unknown as
-            | ID<NonNullable<Def["profile"]>>
+            | ID<NonNullable<this["profile"]>>
             | undefined;
         const rootID = this._raw.get("root") as unknown as
-            | ID<NonNullable<Def["root"]>>
+            | ID<NonNullable<this["root"]>>
             | undefined;
         return {
             profile:
@@ -88,33 +66,32 @@ export class Group<
                     profileID,
                     this._loadedAs,
                     this._schema.profile as RefEncoded<
-                        NonNullable<Def["profile"]>
+                        NonNullable<this["profile"]>
                     >
-                ) as any),
+                ) as any as this["profile"] extends Profile
+                    ? Ref<this["profile"]>
+                    : never),
             root:
                 rootID &&
                 (new Ref(
                     rootID,
                     this._loadedAs,
-                    this._schema.root as RefEncoded<NonNullable<Def["root"]>>
-                ) as any),
+                    this._schema.root as RefEncoded<NonNullable<this["root"]>>
+                ) as any as this["root"] extends CoMap
+                    ? Ref<this["root"]>
+                    : never),
         };
     }
 
-    constructor(options: { owner: Account | Group });
-    constructor(init: any, options: { fromRaw: RawGroup });
-    constructor(init: undefined, options: { owner: Account | Group });
-    constructor(
-        init: undefined | { owner: Account | Group },
-        options?: { fromRaw: RawGroup } | { owner: Account | Group }
-    ) {
+    /** @deprecated Don't use constructor directly, use .create */
+    constructor(options: { fromRaw: RawGroup } | { owner: Account | Group }) {
         super();
         let raw: RawGroup;
 
         if (options && "fromRaw" in options) {
             raw = options.fromRaw;
         } else {
-            const initOwner = options?.owner || init?.owner;
+            const initOwner = options.owner;
             if (!initOwner) throw new Error("No owner provided");
             if (
                 initOwner instanceof Account &&
@@ -143,6 +120,13 @@ export class Group<
         );
     }
 
+    static create<G extends Group>(
+        this: SubclassedConstructor<G>,
+        options: { owner: Account }
+    ) {
+        return new this(options);
+    }
+
     myRole(): Role | undefined {
         return this._raw.myRole();
     }

package/src/coValues/interfaces.ts

@@ -118,7 +118,7 @@ export class CoValueBase implements CoValue {
         this: SubclassedConstructor<V>,
         raw: RawCoValue
     ): V {
-        return new this(undefined, { fromRaw: raw });
+        return new this({ fromRaw: raw });
     }
 
     static loadEf<V extends CoValue>(

package/src/implementation/schema.ts

@@ -9,6 +9,7 @@ export type IfCo<C, R> = C extends infer _A | infer B
         ? R
         : never
     : never;
+export type UnCo<T> = T extends co<infer A> ? A : T;
 
 export const co = {
     string: {

package/src/tests/coList.test.ts

@@ -22,7 +22,7 @@ describe("Simple CoList operations", async () => {
 
     class TestList extends CoList.Of(co.string) {}
 
-    const list = new TestList(["bread", "butter", "onion"], { owner: me });
+    const list = TestList.create(["bread", "butter", "onion"], { owner: me });
 
     test("Construction", () => {
         expect(list[0]).toBe("bread");
@@ -39,7 +39,7 @@ describe("Simple CoList operations", async () => {
 
     describe("Mutation", () => {
         test("assignment", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list[1] = "margarine";
@@ -52,7 +52,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("push", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.push("cheese");
@@ -66,7 +66,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("unshift", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.unshift("lettuce");
@@ -80,7 +80,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("pop", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             expect(list.pop()).toBe("onion");
@@ -89,7 +89,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("shift", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             expect(list.shift()).toBe("bread");
@@ -98,7 +98,7 @@ describe("Simple CoList operations", async () => {
         });
 
         test("splice", () => {
-            const list = new TestList(["bread", "butter", "onion"], {
+            const list = TestList.create(["bread", "butter", "onion"], {
                 owner: me,
             });
             list.splice(1, 1, "salt", "pepper");
@@ -129,14 +129,14 @@ describe("CoList resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const list = new TestList(
+        const list = TestList.create(
             [
-                new NestedList(
-                    [new TwiceNestedList(["a", "b"], { owner: me })],
+                NestedList.create(
+                    [TwiceNestedList.create(["a", "b"], { owner: me })],
                     { owner: me }
                 ),
-                new NestedList(
-                    [new TwiceNestedList(["c", "d"], { owner: me })],
+                NestedList.create(
+                    [TwiceNestedList.create(["c", "d"], { owner: me })],
                     { owner: me }
                 ),
             ],
@@ -196,8 +196,8 @@ describe("CoList resolution", async () => {
         expect(loadedList?.[0]?._refs[0]?.id).toEqual(list[0]?.[0]?.id);
         expect(loadedList?.[0]?._refs[0]?.value).toEqual(loadedTwiceNestedList);
 
-        const otherNestedList = new NestedList(
-            [new TwiceNestedList(["e", "f"], { owner: meOnSecondPeer })],
+        const otherNestedList = NestedList.create(
+            [TwiceNestedList.create(["e", "f"], { owner: meOnSecondPeer })],
             { owner: meOnSecondPeer }
         );
 
@@ -257,11 +257,11 @@ describe("CoList resolution", async () => {
 
                 // When assigning a new nested value, we get an update
 
-                const newTwiceNestedList = new TwiceNestedList(["y", "z"], {
+                const newTwiceNestedList = TwiceNestedList.create(["y", "z"], {
                     owner: meOnSecondPeer,
                 });
 
-                const newNestedList = new NestedList([newTwiceNestedList], {
+                const newNestedList = NestedList.create([newTwiceNestedList], {
                     owner: meOnSecondPeer,
                 });