jazz-tools 0.8.3 → 0.8.11

package/src/exports.ts

@@ -0,0 +1,35 @@
+export type {
+    InviteSecret,
+    Peer,
+    SessionID,
+    AgentID,
+    SyncMessage,
+    CryptoProvider,
+    CoValueUniqueness,
+} from "cojson";
+
+export type { ID, CoValue } from "./internal.js";
+
+export { Encoders, co } from "./internal.js";
+
+export { CoMap, type CoMapInit } from "./internal.js";
+export { CoList } from "./internal.js";
+export { CoStream, BinaryCoStream } from "./internal.js";
+export { Group, Profile } from "./internal.js";
+export { Account, isControlledAccount, type AccountClass } from "./internal.js";
+export { ImageDefinition } from "./internal.js";
+export { CoValueBase, type CoValueClass } from "./internal.js";
+export type { DepthsIn, DeeplyLoaded } from "./internal.js";
+
+export { loadCoValue, subscribeToCoValue, createCoValueObservable } from "./internal.js";
+
+export {
+    type AuthMethod,
+    type AuthResult,
+    createJazzContext,
+    fixedCredentialsAuth,
+    ephemeralCredentialsAuth,
+    AnonymousJazzAgent,
+    createAnonymousJazzContext,
+    randomSessionProvider,
+} from "./internal.js";

package/src/implementation/refs.ts

@@ -48,16 +48,13 @@ export class Ref<out V extends CoValue> {
         }
     }
 
-    private async loadHelper(options?: {
-        onProgress: (p: number) => void;
-    }): Promise<V | "unavailable"> {
+    private async loadHelper(): Promise<V | "unavailable"> {
         const node =
             "node" in this.controlledAccount
                 ? this.controlledAccount.node
                 : this.controlledAccount._raw.core.node;
         const raw = await node.load(
             this.id as unknown as CoID<RawCoValue>,
-            options?.onProgress,
         );
         if (raw === "unavailable") {
             return "unavailable";
@@ -66,10 +63,8 @@ export class Ref<out V extends CoValue> {
         }
     }
 
-    async load(options?: {
-        onProgress: (p: number) => void;
-    }): Promise<V | undefined> {
-        const result = await this.loadHelper(options);
+    async load(): Promise<V | undefined> {
+        const result = await this.loadHelper();
         if (result === "unavailable") {
             return undefined;
         } else {

package/src/implementation/schema.ts

@@ -4,7 +4,19 @@ import {
     type CoValueClass,
     isCoValueClass,
     CoValueFromRaw,
+    SchemaInit,
+    ItemsSym,
+    MembersSym,
 } from "../internal.js";
+import { CoJsonValue } from "cojson/src/jsonValue.js";
+
+/** @category Schema definition */
+export const Encoders = {
+    Date: {
+        encode: (value: Date) => value.toISOString(),
+        decode: (value: JsonValue) => new Date(value as string),
+    },
+};
 
 export type CoMarker = { readonly __co: unique symbol };
 /** @category Schema definition */
@@ -18,7 +30,7 @@ export type UnCo<T> = T extends co<infer A> ? A : T;
 
 const optional = {
     ref: optionalRef,
-    json<T extends JsonValue>(): co<T | undefined> {
+    json<T extends CoJsonValue<T>>(): co<T | undefined> {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
@@ -38,6 +50,9 @@ const optional = {
     null: {
         [SchemaInit]: "json" satisfies Schema,
     } as unknown as co<null | undefined>,
+    Date: {
+        [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
+    } as unknown as co<Date | undefined>,
     literal<T extends (string | number | boolean)[]>(
         ..._lit: T
     ): co<T[number] | undefined> {
@@ -60,13 +75,16 @@ export const co = {
     null: {
         [SchemaInit]: "json" satisfies Schema,
     } as unknown as co<null>,
+    Date: {
+        [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
+    } as unknown as co<Date>,
     literal<T extends (string | number | boolean)[]>(
         ..._lit: T
     ): co<T[number]> {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
-    json<T extends JsonValue>(): co<T> {
+    json<T extends CoJsonValue<T>>(): co<T> {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return { [SchemaInit]: "json" satisfies Schema } as any;
     },
@@ -155,20 +173,10 @@ export type SchemaFor<Field> = NonNullable<Field> extends CoValue
 export type Encoder<V> = {
     encode: (value: V) => JsonValue;
     decode: (value: JsonValue) => V;
-};
+}
 export type OptionalEncoder<V> =
     | Encoder<V>
     | {
           encode: (value: V | undefined) => JsonValue;
           decode: (value: JsonValue) => V | undefined;
       };
-
-import { SchemaInit, ItemsSym, MembersSym } from "./symbols.js";
-
-/** @category Schema definition */
-export const Encoders = {
-    Date: {
-        encode: (value: Date) => value.toISOString(),
-        decode: (value: JsonValue) => new Date(value as string),
-    },
-};

package/src/implementation/subscriptionScope.ts

@@ -26,10 +26,10 @@ export class SubscriptionScope<Root extends CoValue> {
     >();
     rootEntry: {
         state: "loaded";
-        value: Root;
+        value: RawCoValue;
         rawUnsub: () => void;
     };
-    onUpdate: (newRoot: Root) => void;
+    scheduleUpdate: () => void;
     scheduledUpdate: boolean = false;
     cachedValues: { [id: ID<CoValue>]: CoValue } = {};
     parents: { [id: ID<CoValue>]: Set<ID<CoValue>> } = {};
@@ -41,7 +41,7 @@ export class SubscriptionScope<Root extends CoValue> {
     ) {
         this.rootEntry = {
             state: "loaded" as const,
-            value: root,
+            value: root._raw,
             rawUnsub: () => {}, // placeholder
         };
         this.entries.set(root.id, this.rootEntry);
@@ -49,22 +49,21 @@ export class SubscriptionScope<Root extends CoValue> {
         subscriptionsScopes.set(root, this);
 
         this.subscriber = root._loadedAs;
-        this.onUpdate = onUpdate;
+        this.scheduleUpdate = () => {
+            const value = rootSchema.fromRaw(this.rootEntry.value) as Root;
+            subscriptionsScopes.set(value, this);
+            onUpdate(value);
+        };
+
         this.rootEntry.rawUnsub = root._raw.core.subscribe(
             (rawUpdate: RawCoValue | undefined) => {
                 if (!rawUpdate) return;
-                this.rootEntry.value = rootSchema.fromRaw(rawUpdate) as Root;
-                // console.log("root update", this.rootEntry.value.toJSON());
-                subscriptionsScopes.set(this.rootEntry.value, this);
+                this.rootEntry.value = rawUpdate;
                 this.scheduleUpdate();
             },
         );
     }
 
-    scheduleUpdate() {
-        this.onUpdate(this.rootEntry.value);
-    }
-
     onRefAccessedOrSet(
         fromId: ID<CoValue>,
         accessedOrSetId: ID<CoValue> | undefined,

package/src/index.native.ts

@@ -1,40 +1,7 @@
+export * from "./exports.js";
+
 export {
     cojsonInternals,
     MAX_RECOMMENDED_TX_SIZE,
     PureJSCrypto,
 } from "cojson/native";
-export type {
-    InviteSecret,
-    Peer,
-    SessionID,
-    AgentID,
-    SyncMessage,
-    CryptoProvider,
-    CoValueUniqueness,
-} from "cojson";
-
-export type { ID, CoValue } from "./internal.js";
-
-export { Encoders, co } from "./internal.js";
-
-export { CoMap, type CoMapInit } from "./internal.js";
-export { CoList } from "./internal.js";
-export { CoStream, BinaryCoStream } from "./internal.js";
-export { Group, Profile } from "./internal.js";
-export { Account, isControlledAccount, type AccountClass } from "./internal.js";
-export { ImageDefinition } from "./internal.js";
-export { CoValueBase, type CoValueClass } from "./internal.js";
-export type { DepthsIn, DeeplyLoaded } from "./internal.js";
-
-export { loadCoValue, subscribeToCoValue } from "./internal.js";
-
-export {
-    type AuthMethod,
-    type AuthResult,
-    createJazzContext,
-    fixedCredentialsAuth,
-    ephemeralCredentialsAuth,
-    AnonymousJazzAgent,
-    createAnonymousJazzContext,
-    randomSessionProvider,
-} from "./internal.js";

package/src/index.web.ts

@@ -1,36 +1,3 @@
-export { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "cojson";
-export type {
-    InviteSecret,
-    Peer,
-    SessionID,
-    AgentID,
-    SyncMessage,
-    CryptoProvider,
-    CoValueUniqueness,
-} from "cojson";
-
-export type { ID, CoValue } from "./internal.js";
-
-export { Encoders, co } from "./internal.js";
+export * from "./exports.js";
 
-export { CoMap, type CoMapInit } from "./internal.js";
-export { CoList } from "./internal.js";
-export { CoStream, BinaryCoStream } from "./internal.js";
-export { Group, Profile } from "./internal.js";
-export { Account, isControlledAccount, type AccountClass } from "./internal.js";
-export { ImageDefinition } from "./internal.js";
-export { CoValueBase, type CoValueClass } from "./internal.js";
-export type { DepthsIn, DeeplyLoaded } from "./internal.js";
-
-export { loadCoValue, subscribeToCoValue } from "./internal.js";
-
-export {
-    type AuthMethod,
-    type AuthResult,
-    createJazzContext,
-    fixedCredentialsAuth,
-    ephemeralCredentialsAuth,
-    AnonymousJazzAgent,
-    createAnonymousJazzContext,
-    randomSessionProvider,
-} from "./internal.js";
+export { cojsonInternals, MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "cojson";

package/src/tests/coMap.test.ts

@@ -18,7 +18,7 @@ const Crypto = await WasmCrypto.create();
 class TestMap extends CoMap {
     color = co.string;
     _height = co.number;
-    birthday = co.encoded(Encoders.Date);
+    birthday = co.Date;
     name? = co.string;
     nullable = co.optional.encoded<string | undefined>({
         encode: (value: string | undefined) => value || null,

package/src/tests/schema.test.ts

@@ -0,0 +1,205 @@
+import { describe, expectTypeOf, it } from "vitest";
+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;
+        };
+
+        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>;
+            }>();
+    });
+});