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

package/src/coValues/interfaces.ts

@@ -12,10 +12,11 @@ import {
     subscriptionsScopes,
 } from "../internal.js";
 
-export type SubclassedConstructor<T> = {
+export type ClassOf<T> = {
     new (...args: any[]): T;
 };
 
+/** @category Abstract interfaces */
 export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
     /** @category Construction and loading */
     new (init: Init, options: { owner: Account | Group }): Value;
@@ -25,7 +26,7 @@ export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
 
     /** @category Construction and loading */
     load<V extends Value>(
-        this: SubclassedConstructor<V>,
+        this: ClassOf<V>,
         id: ID<V>,
         options: {
             as: Account & Me;
@@ -35,13 +36,13 @@ export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
 
     /** @category Construction and loading */
     loadEf<V extends Value>(
-        this: SubclassedConstructor<V>,
+        this: ClassOf<V>,
         id: ID<V>
     ): Effect.Effect<V, UnavailableError, AccountCtx>;
 
     /** @category Subscription */
     subscribe<V extends Value, Acc extends Account>(
-        this: SubclassedConstructor<V>,
+        this: ClassOf<V>,
         id: ID<V>,
         options: { as: Acc & Me },
         onUpdate: (value: V) => void
@@ -49,30 +50,30 @@ export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
 
     /** @category Subscription */
     subscribeEf<V extends Value>(
-        this: SubclassedConstructor<V>,
+        this: ClassOf<V>,
         id: ID<V>
     ): Stream.Stream<V, UnavailableError, AccountCtx>;
 }
 
-/** @category Schemas & CoValues - Abstract interfaces */
+/** @category Abstract interfaces */
 export interface CoValue<Type extends string = string, Raw = any> {
-    /** @category Value identity */
+    /** @category Content */
     readonly id: ID<this>;
-    /** @category Value identity */
+    /** @category Type Helpers */
     _type: Type;
     /** @category Collaboration */
     _owner: Account | Group;
-    /** @category Subscription */
+    /** @category Subscription & Loading */
     subscribe(listener: (update: this) => void): () => void;
-    /** @category Subscription */
+    /** @category Subscription & Loading */
     subscribeEf(): Stream.Stream<this, UnavailableError, never>;
     /** @category Internals */
     _raw: Raw;
-    /** @category Internals */
+    /** @internal */
     readonly _loadedAs: Account & Me;
-    /** @category Stringifying & inspection */
+    /** @category Stringifying & Inspection */
     toJSON(): any[] | object;
-    /** @category Stringifying & inspection */
+    /** @category Stringifying & Inspection */
     [inspect](): any;
 }
 
@@ -83,11 +84,12 @@ export function isCoValueClass(value: any): value is CoValueClass {
     return typeof value === "function" && value.fromRaw !== undefined;
 }
 
-/** @category Schemas & CoValues - Abstract interfaces */
+/** @category CoValues */
 export type ID<T> = CojsonInternalTypes.RawCoID & IDMarker<T>;
 
 type IDMarker<out T> = { __type(_: never): T };
 
+/** @internal */
 export class CoValueBase implements CoValue {
     id!: ID<this>;
     _type!: string;
@@ -114,15 +116,17 @@ export class CoValueBase implements CoValue {
 
     constructor(..._args: any) {}
 
+    /** @category Internals */
     static fromRaw<V extends CoValue>(
-        this: SubclassedConstructor<V>,
+        this: ClassOf<V>,
         raw: RawCoValue
     ): V {
-        return new this(undefined, { fromRaw: raw });
+        return new this({ fromRaw: raw });
     }
 
+    /** @category Subscription & Loading */
     static loadEf<V extends CoValue>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
+        this: ClassOf<V> & typeof CoValueBase,
         id: ID<V>
     ): Effect.Effect<V, UnavailableError, AccountCtx> {
         return Effect.gen(this, function* (_) {
@@ -133,8 +137,9 @@ export class CoValueBase implements CoValue {
         });
     }
 
+    /** @category Subscription & Loading */
     static load<V extends CoValue>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
+        this: ClassOf<V> & typeof CoValueBase,
         id: ID<V>,
         options: {
             as: Account & Me;
@@ -146,8 +151,9 @@ export class CoValueBase implements CoValue {
         );
     }
 
+    /** @category Subscription & Loading */
     static subscribe<V extends CoValue, Acc extends Account>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
+        this: ClassOf<V> & typeof CoValueBase,
         id: ID<V>,
         options: { as: Acc & Me },
         onUpdate: (value: V) => void
@@ -169,8 +175,9 @@ export class CoValueBase implements CoValue {
         return function unsubscribe() {};
     }
 
+    /** @category Subscription & Loading */
     static subscribeEf<V extends CoValue>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
+        this: ClassOf<V> & typeof CoValueBase,
         id: ID<V>
     ): Stream.Stream<V, UnavailableError, AccountCtx> {
         return Stream.fromEffect(this.loadEf(id)).pipe(
@@ -196,6 +203,7 @@ export class CoValueBase implements CoValue {
         );
     }
 
+    /** @category Subscription & Loading */
     subscribe(listener: (update: this) => void): () => void {
         return (this.constructor as unknown as typeof CoValueBase).subscribe(
             this.id as unknown as ID<CoValue>,
@@ -204,6 +212,7 @@ export class CoValueBase implements CoValue {
         );
     }
 
+    /** @category Subscription & Loading */
     subscribeEf(): Stream.Stream<this, UnavailableError, never> {
         return Stream.provideService(
             (this.constructor as unknown as typeof CoValueBase).subscribeEf(
@@ -226,6 +235,7 @@ export class CoValueBase implements CoValue {
         return this.toJSON();
     }
 
+    /** @category Type Helpers*/
     as<C extends CoValueClass>(otherSchema: C): InstanceType<C> {
         const cast = otherSchema.fromRaw(this._raw) as InstanceType<C>;
         const subScope = subscriptionsScopes.get(this);

package/src/implementation/schema.ts

@@ -3,13 +3,16 @@ import { type CoValue, type CoValueClass, isCoValueClass } from "../internal.js"
 import type { Schema as EffectSchema,  TypeId } from "@effect/schema/Schema";
 
 export type CoMarker = { readonly __co: unique symbol };
+/** @category Schema definition */
 export type co<T> = T | (T & CoMarker);
 export type IfCo<C, R> = C extends infer _A | infer B
     ? B extends CoMarker
         ? R
         : never
     : never;
+export type UnCo<T> = T extends co<infer A> ? A : T;
 
+/** @category Schema definition */
 export const co = {
     string: {
         [SchemaInit]: "json" satisfies Schema,
@@ -23,7 +26,7 @@ export const co = {
     null: {
         [SchemaInit]: "json" satisfies Schema,
     } as unknown as co<null>,
-    literal: <T extends string | number | boolean>(_lit: T): co<T> => {
+    literal: <T extends (string | number | boolean)[]>(..._lit: T): co<T[number]> => {
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
     json: <T extends JsonValue>(): co<T> => {
@@ -86,6 +89,7 @@ export type Encoder<V> = EffectSchemaWithInputAndOutput<V, JsonValue>;
 import { Date } from "@effect/schema/Schema";
 import { SchemaInit, ItemsSym, MembersSym } from "./symbols.js";
 
+/** @category Schema definition */
 export const Encoders = {
     Date,
 };

package/src/implementation/subscriptionScope.ts

@@ -1,5 +1,5 @@
 import type { RawCoValue } from "cojson";
-import type { Account, CoValue, CoValueBase, ID, Me, SubclassedConstructor } from "../internal.js";
+import type { Account, CoValue, CoValueBase, ID, Me, ClassOf } from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
     CoValue,
@@ -26,7 +26,7 @@ export class SubscriptionScope<
 
     constructor(
         root: Root,
-        rootSchema: SubclassedConstructor<Root> & typeof CoValueBase,
+        rootSchema: ClassOf<Root> & typeof CoValueBase,
         onUpdate: (newRoot: Root) => void
     ) {
         this.rootEntry = {

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,
                 });
 

package/src/tests/coMap.test.ts

@@ -20,7 +20,7 @@ describe("Simple CoMap operations", async () => {
         creationProps: { name: "Hermes Puggington" },
     });
 
-    class TestMap extends CoMap<TestMap> {
+    class TestMap extends CoMap {
         color = co.string;
         _height = co.number;
         birthday = co.encoded(Encoders.Date);
@@ -35,7 +35,7 @@ describe("Simple CoMap operations", async () => {
 
     const birthday = new Date();
 
-    const map = new TestMap(
+    const map = TestMap.create(
         {
             color: "red",
             _height: 10,
@@ -80,18 +80,18 @@ describe("Simple CoMap operations", async () => {
         });
     });
 
-    class RecursiveMap extends CoMap<RecursiveMap> {
+    class RecursiveMap extends CoMap {
         name = co.string;
         next: co<RecursiveMap | null> = co.ref(RecursiveMap);
     }
 
-    const recursiveMap = new RecursiveMap(
+    const recursiveMap = RecursiveMap.create(
         {
             name: "first",
-            next: new RecursiveMap(
+            next: RecursiveMap.create(
                 {
                     name: "second",
-                    next: new RecursiveMap(
+                    next: RecursiveMap.create(
                         {
                             name: "third",
                         },
@@ -112,27 +112,27 @@ describe("Simple CoMap operations", async () => {
         });
     });
 
-    class MapWithEnumOfMaps extends CoMap<MapWithEnumOfMaps> {
+    class MapWithEnumOfMaps extends CoMap {
         name = co.string;
         child = co.ref<typeof ChildA | typeof ChildB>((raw) =>
             raw.get("type") === "a" ? ChildA : ChildB
         );
     }
 
-    class ChildA extends CoMap<ChildA> {
+    class ChildA extends CoMap {
         type = co.literal("a");
         value = co.number;
     }
 
-    class ChildB extends CoMap<ChildB> {
+    class ChildB extends CoMap {
         type = co.literal("b");
         value = co.string;
     }
 
-    const mapWithEnum = new MapWithEnumOfMaps(
+    const mapWithEnum = MapWithEnumOfMaps.create(
         {
             name: "enum",
-            child: new ChildA(
+            child: ChildA.create(
                 {
                     type: "a",
                     value: 5,
@@ -150,7 +150,7 @@ describe("Simple CoMap operations", async () => {
         expect(mapWithEnum.child?.id).toBeDefined();
     });
 
-    class SuperClassMap extends CoMap<SuperClassMap> {
+    class SuperClassMap extends CoMap {
         name = co.string;
     }
 
@@ -159,11 +159,11 @@ describe("Simple CoMap operations", async () => {
         value = co.number;
         extra = co.ref(TestMap);
     }
-    interface SubClassMap extends CoMap<SubClassMap> {}
+    interface SubClassMap extends CoMap {}
 
     class GenericMapWithLoose<
         out T extends string = string,
-    > extends CoMap<GenericMapWithLoose> {
+    > extends CoMap {
         name = co.json<T>();
     }
 
@@ -173,11 +173,11 @@ describe("Simple CoMap operations", async () => {
 });
 
 describe("CoMap resolution", async () => {
-    class TwiceNestedMap extends CoMap<TwiceNestedMap> {
+    class TwiceNestedMap extends CoMap {
         taste = co.string;
     }
 
-    class NestedMap extends CoMap<NestedMap> {
+    class NestedMap extends CoMap {
         name = co.string;
         twiceNested = co.ref(TwiceNestedMap);
 
@@ -186,7 +186,7 @@ describe("CoMap resolution", async () => {
         }
     }
 
-    class TestMap extends CoMap<TestMap> {
+    class TestMap extends CoMap {
         color = co.string;
         height = co.number;
         nested = co.ref(NestedMap);
@@ -201,14 +201,14 @@ describe("CoMap resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const map = new TestMap(
+        const map = TestMap.create(
             {
                 color: "red",
                 height: 10,
-                nested: new NestedMap(
+                nested: NestedMap.create(
                     {
                         name: "nested",
-                        twiceNested: new TwiceNestedMap(
+                        twiceNested: TwiceNestedMap.create(
                             { taste: "sour" },
                             { owner: me }
                         ),
@@ -278,10 +278,10 @@ describe("CoMap resolution", async () => {
             loadedTwiceNestedMap
         );
 
-        const otherNestedMap = new NestedMap(
+        const otherNestedMap = NestedMap.create(
             {
                 name: "otherNested",
-                twiceNested: new TwiceNestedMap(
+                twiceNested: TwiceNestedMap.create(
                     { taste: "sweet" },
                     { owner: meOnSecondPeer }
                 ),
@@ -347,14 +347,14 @@ describe("CoMap resolution", async () => {
                 expect(oldTwiceNested?.taste).toEqual("sour");
 
                 // When assigning a new nested value, we get an update
-                const newTwiceNested = new TwiceNestedMap(
+                const newTwiceNested = TwiceNestedMap.create(
                     {
                         taste: "sweet",
                     },
                     { owner: meOnSecondPeer }
                 );
 
-                const newNested = new NestedMap(
+                const newNested = NestedMap.create(
                     {
                         name: "newNested",
                         twiceNested: newTwiceNested,
@@ -383,7 +383,7 @@ describe("CoMap resolution", async () => {
         );
     });
 
-    class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
+    class TestMapWithOptionalRef extends CoMap {
         color = co.string;
         nested? = co.ref(NestedMap);
     }
@@ -393,7 +393,7 @@ describe("CoMap resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const mapWithout = new TestMapWithOptionalRef(
+        const mapWithout = TestMapWithOptionalRef.create(
             {
                 color: "red",
             },
@@ -403,13 +403,13 @@ describe("CoMap resolution", async () => {
         expect(mapWithout.color).toEqual("red");
         expect(mapWithout.nested).toEqual(undefined);
 
-        const mapWith = new TestMapWithOptionalRef(
+        const mapWith = TestMapWithOptionalRef.create(
             {
                 color: "red",
-                nested: new NestedMap(
+                nested: NestedMap.create(
                     {
                         name: "wow!",
-                        twiceNested: new TwiceNestedMap(
+                        twiceNested: TwiceNestedMap.create(
                             { taste: "sour" },
                             { owner: me }
                         ),
@@ -426,7 +426,7 @@ describe("CoMap resolution", async () => {
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends CoMap<TestRecord> {
+    class TestRecord extends CoMap {
         [co.items] = co.number;
     }
     interface TestRecord extends Record<string, number> {}
@@ -436,7 +436,7 @@ describe("CoMap resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const record = new TestRecord(
+        const record = TestRecord.create(
             {
                 height: 5,
                 other: 3,
@@ -464,7 +464,7 @@ describe("CoMap resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const record = new TestRecord2(
+        const record = TestRecord2.create(
             {
                 height: 5,
                 other: 3,
@@ -486,13 +486,13 @@ describe("CoMap resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const record = new TestRecordRef(
+        const record = TestRecordRef.create(
             {
-                firstNested: new TwiceNestedMap(
+                firstNested: TwiceNestedMap.create(
                     { taste: "sour" },
                     { owner: me }
                 ),
-                secondNested: new TwiceNestedMap(
+                secondNested: TwiceNestedMap.create(
                     { taste: "sweet" },
                     { owner: me }
                 ),

package/src/tests/coStream.test.ts

@@ -23,7 +23,7 @@ describe("Simple CoStream operations", async () => {
 
     class TestStream extends CoStream.Of(co.string) {}
 
-    const stream = new TestStream(["milk"], { owner: me });
+    const stream = TestStream.create(["milk"], { owner: me });
 
     test("Construction", () => {
         expect(stream[me.id]?.value).toEqual("milk");
@@ -59,10 +59,10 @@ describe("CoStream resolution", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const stream = new TestStream(
+        const stream = TestStream.create(
             [
-                new NestedStream(
-                    [new TwiceNestedStream(["milk"], { owner: me })],
+                NestedStream.create(
+                    [TwiceNestedStream.create(["milk"], { owner: me })],
                     { owner: me }
                 ),
             ],
@@ -143,8 +143,8 @@ describe("CoStream resolution", async () => {
             loadedTwiceNestedStream?.id
         );
 
-        const otherNestedStream = new NestedStream(
-            [new TwiceNestedStream(["butter"], { owner: meOnSecondPeer })],
+        const otherNestedStream = NestedStream.create(
+            [TwiceNestedStream.create(["butter"], { owner: meOnSecondPeer })],
             { owner: meOnSecondPeer }
         );
         loadedStream?.push(otherNestedStream);
@@ -229,11 +229,11 @@ describe("CoStream resolution", async () => {
                 ).toBe("bread");
 
                 // When assigning a new nested stream, we get an update
-                const newTwiceNested = new TwiceNestedStream(["butter"], {
+                const newTwiceNested = TwiceNestedStream.create(["butter"], {
                     owner: meOnSecondPeer,
                 });
 
-                const newNested = new NestedStream([newTwiceNested], {
+                const newNested = NestedStream.create([newTwiceNested], {
                     owner: meOnSecondPeer,
                 });
 
@@ -260,7 +260,7 @@ describe("Simple BinaryCoStream operations", async () => {
         creationProps: { name: "Hermes Puggington" },
     });
 
-    const stream = new BinaryCoStream(undefined, { owner: me });
+    const stream = BinaryCoStream.create({ owner: me });
 
     test("Construction", () => {
         expect(stream.getChunks()).toBe(undefined);
@@ -288,7 +288,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
             creationProps: { name: "Hermes Puggington" },
         });
 
-        const stream = new BinaryCoStream(undefined, { owner: me });
+        const stream = BinaryCoStream.create({ owner: me });
 
         stream.start({ mimeType: "text/plain" });
         stream.push(new Uint8Array([1, 2, 3]));
@@ -336,7 +336,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
     test("Subscription", async () => {
         const { me } = await initNodeAndStream();
 
-        const stream = new BinaryCoStream(undefined, { owner: me });
+        const stream = BinaryCoStream.create({ owner: me });
 
         const [initialAsPeer, secondAsPeer] = connectedPeers(
             "initial",