jazz-tools 0.7.0-alpha.1 → 0.7.0-alpha.3

package/src/coValues/coMap.ts

@@ -70,15 +70,15 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
     }
     _raw!: RawCoMap;
 
-    static _schema: any;
-    get _schema(): {
+    static _encoding: any;
+    get _encoding(): {
         [Key in OwnKeys<Fields>]: FieldDescriptorFor<Fields[Key]>;
     } & {
         [indexSignature]: indexSignature extends keyof Fields
             ? FieldDescriptorFor<Fields[indexSignature]>
             : never;
     } {
-        return (this.constructor as typeof CoMap)._schema;
+        return (this.constructor as typeof CoMap)._encoding;
     }
 
     get _refs(): {
@@ -91,14 +91,14 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
         return makeRefs<OwnKeys<Fields>>(
             (key) => this._raw.get(key as string) as unknown as ID<CoValue>,
             () =>
-                Object.keys(this._schema).filter((key) => {
-                    const schema = this._schema[
-                        key as keyof typeof this._schema
+                Object.keys(this._encoding).filter((key) => {
+                    const schema = this._encoding[
+                        key as keyof typeof this._encoding
                     ] as FieldDescriptor;
                     schema !== "json" && "ref" in schema;
                 }) as OwnKeys<Fields>[],
             this._loadedAs,
-            (key) => (this._schema[key] as RefField<CoValue>).ref()
+            (key) => (this._encoding[key] as RefField<CoValue>).ref()
         ) as any;
     }
 
@@ -115,8 +115,8 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
                 const rawEdit = target._raw.lastEditAt(key as string);
                 if (!rawEdit) return undefined;
 
-                const descriptor = target._schema[
-                    key as keyof typeof target._schema
+                const descriptor = target._encoding[
+                    key as keyof typeof target._encoding
                 ] as FieldDescriptor;
 
                 return {
@@ -168,7 +168,7 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
     ) {
         super();
 
-        if (!this._schema) {
+        if (!this._encoding) {
             throw new Error(
                 "No schema found in " +
                     this.constructor.name +
@@ -188,7 +188,7 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
 
         this.definePropertiesFromSchema();
 
-        if (this._schema[indexSignature]) {
+        if (this._encoding[indexSignature]) {
             return new Proxy(this, CoMapProxyHandler<Fields>());
         }
     }
@@ -196,7 +196,7 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
     toJSON() {
         const jsonedFields = this._raw.keys().map((key) => {
             const tKey = key as OwnKeys<Fields>;
-            const descriptor = this._schema[tKey] as FieldDescriptor;
+            const descriptor = this._encoding[tKey] as FieldDescriptor;
 
             if (descriptor == "json" || "encode" in descriptor) {
                 return [key, this._raw.get(key)];
@@ -238,9 +238,9 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
                 for (const key of Object.keys(init) as (keyof Fields)[]) {
                     const initValue = init[key as keyof typeof init];
 
-                    const descriptor = (this._schema[
-                        key as keyof typeof this._schema
-                    ] || this._schema[indexSignature]) as FieldDescriptor;
+                    const descriptor = (this._encoding[
+                        key as keyof typeof this._encoding
+                    ] || this._encoding[indexSignature]) as FieldDescriptor;
 
                     if (descriptor === "json") {
                         rawInit[key] = initValue as JsonValue;
@@ -263,17 +263,17 @@ export class CoMap<Fields extends EnsureValid<Fields> = DefaultFields>
     static encoding<V extends CoMap>(
         this: { new (...args: any): V } & typeof CoMap,
         fields: Simplify<{
-            [Key in keyof V["_schema"] as V["_schema"][Key] extends never
+            [Key in keyof V["_encoding"] as V["_encoding"][Key] extends never
                 ? never
-                : Key]: Simplify<V["_schema"][Key]>;
+                : Key]: Simplify<V["_encoding"][Key]>;
         }>
     ) {
-        this._schema ||= {};
-        Object.assign(this._schema, fields);
+        this._encoding ||= {};
+        Object.assign(this._encoding, fields);
     }
 
     private definePropertiesFromSchema() {
-        for (const [key, fieldSchema] of Object.entries(this._schema)) {
+        for (const [key, fieldSchema] of Object.entries(this._encoding)) {
             if (key === "indexSignature") continue;
             const descriptor = fieldSchema as FieldDescriptor;
             if (descriptor === "json") {
@@ -374,7 +374,7 @@ function CoMapProxyHandler<Fields extends EnsureValid<Fields>>(): ProxyHandler<
 > {
     return {
         get(target, key, receiver) {
-            const descriptor = target._schema[
+            const descriptor = target._encoding[
                 indexSignature
             ] as FieldDescriptor;
             if (key in target || typeof key === "symbol") {
@@ -400,7 +400,7 @@ function CoMapProxyHandler<Fields extends EnsureValid<Fields>>(): ProxyHandler<
             }
         },
         set(target, key, value, receiver) {
-            const descriptor = target._schema[
+            const descriptor = target._encoding[
                 indexSignature
             ] as FieldDescriptor;
             if (key in target || typeof key === "symbol") {

package/src/coValues/coStream.ts

@@ -44,11 +44,11 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
 
     /** @internal This is only a marker type and doesn't exist at runtime */
     _item!: Item;
-    static _schema: any;
-    get _schema(): {
+    static _encoding: any;
+    get _encoding(): {
         _item: FieldDescriptorFor<Item>;
     } {
-        return (this.constructor as typeof CoStream)._schema;
+        return (this.constructor as typeof CoStream)._encoding;
     }
 
     by: {
@@ -111,7 +111,7 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
                         rawEntry,
                         this._loadedAs,
                         accountID as unknown as ID<Account>,
-                        this._schema._item
+                        this._encoding._item
                     );
                 },
                 configurable: true,
@@ -138,7 +138,7 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
                         cojsonInternals.isAccountID(by)
                             ? (by as unknown as ID<Account>)
                             : undefined,
-                        this._schema._item
+                        this._encoding._item
                     );
                 },
                 configurable: true,
@@ -155,7 +155,7 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
     }
 
     private pushItem(item: Item) {
-        const itemDescriptor = this._schema._item as FieldDescriptor;
+        const itemDescriptor = this._encoding._item as FieldDescriptor;
 
         if (itemDescriptor === "json") {
             this._raw.push(item as JsonValue);
@@ -167,7 +167,7 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
     }
 
     toJSON() {
-        const itemDescriptor = this._schema._item as FieldDescriptor;
+        const itemDescriptor = this._encoding._item as FieldDescriptor;
         const mapper =
             itemDescriptor === "json"
                 ? (v: unknown) => v
@@ -199,10 +199,10 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
 
     static encoding<V extends CoStream>(
         this: { new (...args: any): V } & typeof CoStream,
-        def: { _item: V["_schema"]["_item"] }
+        def: { _item: V["_encoding"]["_item"] }
     ) {
-        this._schema ||= {};
-        Object.assign(this._schema, def);
+        this._encoding ||= {};
+        Object.assign(this._encoding, def);
     }
 }
 

package/src/coValues/extensions/imageDef.ts

@@ -1,20 +1,16 @@
-import { BinaryCoStream, CoMap, indexSignature, subscriptionsScopes } from '../../internal.js'
+import {
+    BinaryCoStream,
+    CoMap,
+    indexSignature,
+    subscriptionsScopes,
+} from "../../internal.js";
 
 export class ImageDefinition extends CoMap<ImageDefinition> {
-    declare originalSize: [number, number]
-    declare placeholderDataURL?: string
+    declare originalSize: [number, number];
+    declare placeholderDataURL?: string;
 
     [res: `${number}x${number}`]: BinaryCoStream | null;
-    declare [indexSignature]: BinaryCoStream | null
-
-    static {
-        this.prototype._schema
-        this.encoding({
-            originalSize: "json",
-            placeholderDataURL: "json",
-            [indexSignature]: {ref: () => BinaryCoStream},
-        })
-    }
+    declare [indexSignature]: BinaryCoStream | null;
 
     get _highestResAvailable():
         | { res: `${number}x${number}`; stream: BinaryCoStream }
@@ -57,3 +53,8 @@ export class ImageDefinition extends CoMap<ImageDefinition> {
         );
     }
 }
+ImageDefinition.encoding({
+    originalSize: "json",
+    placeholderDataURL: "json",
+    [indexSignature]: { ref: () => BinaryCoStream },
+});

package/src/coValues/group.ts

@@ -16,11 +16,8 @@ import {
 
 export class Profile extends CoMap<{ name: string }> {
     declare name: string;
-
-    static {
-        this.encoding({ name: "json" } as any);
-    }
 }
+Profile.encoding({ name: "json" });
 
 export class Group<
         Def extends { profile: Profile | null; root: CoMap | null } = {
@@ -38,8 +35,8 @@ export class Group<
     }
     _raw!: RawGroup;
 
-    static _schema: any;
-    get _schema(): {
+    static _encoding: any;
+    get _encoding(): {
         profile: Def["profile"] extends CoValue
             ? RefField<Def["profile"]>
             : PrimitiveField;
@@ -47,15 +44,15 @@ export class Group<
             ? RefField<Def["root"]>
             : PrimitiveField;
     } {
-        return (this.constructor as typeof Group)._schema;
+        return (this.constructor as typeof Group)._encoding;
     }
     static {
-        this._schema = {
+        this._encoding = {
             profile: { json: true },
             root: { json: true },
         } as any;
-        Object.defineProperty(this.prototype, "_schema", {
-            get: () => this._schema,
+        Object.defineProperty(this.prototype, "_encoding", {
+            get: () => this._encoding,
         });
     }
 
@@ -84,7 +81,7 @@ export class Group<
                     profileID,
                     this._loadedAs,
                     (
-                        this._schema.profile as RefField<
+                        this._encoding.profile as RefField<
                             NonNullable<Def["profile"]>
                         >
                     ).ref()
@@ -95,7 +92,9 @@ export class Group<
                     rootID,
                     this._loadedAs,
                     (
-                        this._schema.root as RefField<NonNullable<Def["root"]>>
+                        this._encoding.root as RefField<
+                            NonNullable<Def["root"]>
+                        >
                     ).ref()
                 ) as any),
         };
@@ -177,11 +176,11 @@ export class Group<
     static define<V extends Account>(
         this: CoValueClass<V> & typeof Account,
         fields: {
-            profile: V["_schema"]["profile"];
-            root: V["_schema"]["root"];
+            profile: V["_encoding"]["profile"];
+            root: V["_encoding"]["root"];
         }
     ) {
-        this._schema ||= {};
-        Object.assign(this._schema, fields);
+        this._encoding ||= {};
+        Object.assign(this._encoding, fields);
     }
 }

package/src/implementation/refs.ts

@@ -1,7 +1,15 @@
 import { Effect } from "effect";
 import type { CoID, RawCoValue } from "cojson";
-import type { Account, CoValue, ID, Me, SubclassedConstructor, UnavailableError, indexSignature} from '../internal.js';
-import { subscriptionsScopes } from '../internal.js';
+import type {
+    Account,
+    CoValue,
+    ID,
+    Me,
+    SubclassedConstructor,
+    UnavailableError,
+    indexSignature,
+} from "../internal.js";
+import { subscriptionsScopes } from "../internal.js";
 
 export class ValueRef<V extends CoValue> {
     private cachedValue: V | undefined;
@@ -19,7 +27,9 @@ export class ValueRef<V extends CoValue> {
             this.id as unknown as CoID<RawCoValue>
         );
         if (raw) {
-            const value = new this.valueConstructor(undefined, { fromRaw: raw }) as V;
+            const value = new this.valueConstructor(undefined, {
+                fromRaw: raw,
+            }) as V;
             this.cachedValue = value;
             return value;
         } else {
@@ -43,7 +53,9 @@ export class ValueRef<V extends CoValue> {
         });
     }
 
-    private async loadHelper(options?: {onProgress: (p: number) => void}): Promise<V | "unavailable"> {
+    private async loadHelper(options?: {
+        onProgress: (p: number) => void;
+    }): Promise<V | "unavailable"> {
         const raw = await this.controlledAccount._raw.core.node.load(
             this.id as unknown as CoID<RawCoValue>,
             options?.onProgress
@@ -51,12 +63,17 @@ export class ValueRef<V extends CoValue> {
         if (raw === "unavailable") {
             return "unavailable";
         } else {
-            return new ValueRef(this.id, this.controlledAccount, this.valueConstructor)
-                .value!;
+            return new ValueRef(
+                this.id,
+                this.controlledAccount,
+                this.valueConstructor
+            ).value!;
         }
     }
 
-    async load(options?: {onProgress: (p: number) => void}): Promise<V | undefined> {
+    async load(options?: {
+        onProgress: (p: number) => void;
+    }): Promise<V | undefined> {
         const result = await this.loadHelper(options);
         if (result === "unavailable") {
             return undefined;
@@ -82,9 +99,15 @@ export function makeRefs<Keys extends string | number | indexSignature>(
     getIdForKey: (key: Keys) => ID<CoValue> | undefined,
     getKeysWithIds: () => Keys[],
     controlledAccount: Account & Me,
-    valueConstructorForKey: (key: Keys) => SubclassedConstructor<CoValue>,
-): { [K in Keys]: ValueRef<CoValue> } {
-    const refs = {} as { [K in Keys]: ValueRef<CoValue> };
+    valueConstructorForKey: (key: Keys) => SubclassedConstructor<CoValue>
+): { [K in Keys]: ValueRef<CoValue> } & {
+    [Symbol.iterator]: () => IterableIterator<ValueRef<CoValue>>;
+    length: number;
+} {
+    const refs = {} as { [K in Keys]: ValueRef<CoValue> } & {
+        [Symbol.iterator]: () => IterableIterator<ValueRef<CoValue>>;
+        length: number;
+    };
     return new Proxy(refs, {
         get(target, key) {
             if (key === Symbol.iterator) {

package/src/index.ts

@@ -1,20 +1,3 @@
-/* eslint-disable @typescript-eslint/no-namespace */
-import { BinaryCoStream, CoMap, ImageDefinition, Account as Account_, Group as Group_, CoList, CoStream } from "./internal.js";
-
-/** @category Schemas & CoValues - Schema definers */
-export namespace Co {
-    export const Map = CoMap;
-    export const List = CoList;
-    export const Stream = CoStream;
-    export const BinaryStream = BinaryCoStream;
-    export const Account = Account_;
-    export const Group = Group_;
-    export namespace media {
-        export const ImageDef = ImageDefinition;
-        export type ImageDef = ImageDefinition;
-    }
-}
-
 /** @category Internal types */
 export {
     cojsonReady as jazzReady,

package/src/tests/coList.test.ts

@@ -4,7 +4,7 @@ import { webcrypto } from "node:crypto";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Co, Account, jazzReady } from "..";
+import { Account, CoList, jazzReady } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,7 +20,7 @@ describe("Simple CoList operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestList extends Co.List<string> {}
+    class TestList extends CoList<string> {}
     TestList.encoding({ _item: "json" });
 
     const list = new TestList(["bread", "butter", "onion"], { owner: me });
@@ -115,17 +115,17 @@ describe("Simple CoList operations", async () => {
 });
 
 describe("CoList resolution", async () => {
-    class TwiceNestedList extends Co.List<string> {
+    class TwiceNestedList extends CoList<string> {
         joined() {
             return this.join(",");
         }
     }
     TwiceNestedList.encoding({ _item: "json" });
 
-    class NestedList extends Co.List<TwiceNestedList | null> {}
+    class NestedList extends CoList<TwiceNestedList | null> {}
     NestedList.encoding({ _item: { ref: () => TwiceNestedList } });
 
-    class TestList extends Co.List<NestedList | null> {}
+    class TestList extends CoList<NestedList | null> {}
     TestList.encoding({ _item: { ref: () => NestedList } });
 
     const initNodeAndList = async () => {

package/src/tests/coMap.test.ts

@@ -4,7 +4,7 @@ import { webcrypto } from "node:crypto";
 import { connectedPeers } from "cojson/src/streamUtils.js";
 import { newRandomSessionID } from "cojson/src/coValueCore.js";
 import { Effect, Queue } from "effect";
-import { Co, Account, jazzReady, Encoders, indexSignature } from "..";
+import { Account, jazzReady, Encoders, indexSignature, CoMap } from "..";
 
 if (!("crypto" in globalThis)) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,7 +20,7 @@ describe("Simple CoMap operations", async () => {
         name: "Hermes Puggington",
     });
 
-    class TestMap extends Co.Map<TestMap> {
+    class TestMap extends CoMap<TestMap> {
         declare color: string;
         declare height: number;
         declare birthday: Date;
@@ -29,18 +29,15 @@ describe("Simple CoMap operations", async () => {
         get _roughColor() {
             return this.color + "ish";
         }
-
-        static {
-            this.encoding({
-                color: "json",
-                height: "json",
-                birthday: { encoded: Encoders.Date },
-                name: "json",
-            });
-        }
     }
+    TestMap.encoding({
+        color: "json",
+        height: "json",
+        birthday: { encoded: Encoders.Date },
+        name: "json",
+    });
 
-    console.log("TestMap schema", TestMap.prototype._schema);
+    console.log("TestMap schema", TestMap.prototype._encoding);
 
     const birthday = new Date();
 
@@ -84,17 +81,15 @@ describe("Simple CoMap operations", async () => {
         });
     });
 
-    class RecursiveMap extends Co.Map<RecursiveMap> {
+    class RecursiveMap extends CoMap<RecursiveMap> {
         declare name: string;
         declare next: RecursiveMap | null;
-
-        static {
-            this.encoding({
-                name: "json",
-                next: { ref: () => RecursiveMap },
-            });
-        }
     }
+    RecursiveMap.encoding({
+        name: "json",
+        next: { ref: () => RecursiveMap },
+    });
+
     const recursiveMap = new RecursiveMap(
         {
             name: "first",
@@ -124,14 +119,14 @@ describe("Simple CoMap operations", async () => {
 });
 
 describe("CoMap resolution", async () => {
-    class TwiceNestedMap extends Co.Map<TwiceNestedMap> {
+    class TwiceNestedMap extends CoMap<TwiceNestedMap> {
         taste!: string;
     }
     TwiceNestedMap.encoding({
         taste: "json",
     });
 
-    class NestedMap extends Co.Map<NestedMap> {
+    class NestedMap extends CoMap<NestedMap> {
         name!: string;
         twiceNested!: TwiceNestedMap | null;
 
@@ -144,23 +139,20 @@ describe("CoMap resolution", async () => {
         twiceNested: { ref: () => TwiceNestedMap },
     });
 
-    class TestMap extends Co.Map<TestMap> {
+    class TestMap extends CoMap<TestMap> {
         declare color: string;
         declare height: number;
         declare nested: NestedMap | null;
 
-        static {
-            this.encoding({
-                color: "json",
-                height: "json",
-                nested: { ref: () => NestedMap },
-            });
-        }
-
         get _roughColor() {
             return this.color + "ish";
         }
     }
+    TestMap.encoding({
+        color: "json",
+        height: "json",
+        nested: { ref: () => NestedMap },
+    });
 
     const initNodeAndMap = async () => {
         const me = await Account.create({
@@ -349,17 +341,14 @@ describe("CoMap resolution", async () => {
         );
     });
 
-    class TestMapWithOptionalRef extends Co.Map<TestMapWithOptionalRef> {
+    class TestMapWithOptionalRef extends CoMap<TestMapWithOptionalRef> {
         declare color: string;
         declare nested?: NestedMap | null;
-
-        static {
-            this.encoding({
-                color: "json",
-                nested: { ref: () => NestedMap },
-            });
-        }
     }
+    TestMapWithOptionalRef.encoding({
+        color: "json",
+        nested: { ref: () => NestedMap },
+    });
 
     test("Construction with optional", async () => {
         const me = await Account.create({
@@ -399,16 +388,13 @@ describe("CoMap resolution", async () => {
         expect(mapWith.nested?._raw).toBeDefined();
     });
 
-    class TestRecord extends Co.Map<TestRecord> {
+    class TestRecord extends CoMap<TestRecord> {
         declare [indexSignature]: number;
-
-        static {
-            this.encoding({
-                [indexSignature]: "json"
-            });
-        }
     }
     interface TestRecord extends Record<string, number> {}
+    TestRecord.encoding({
+        [indexSignature]: "json",
+    });
 
     test("Construction with index signature", async () => {
         const me = await Account.create({