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

package/src/coValues/coStream.ts

@@ -11,181 +11,151 @@ import type {
 import { cojsonInternals } from "cojson";
 import type {
     CoValue,
-    EnsureItemNullable,
-    FieldDescriptor,
-    FieldDescriptorFor,
+    Schema,
+    SchemaFor,
     Group,
     ID,
     Me,
+    IfCo,
+    SubclassedConstructor,
+    UnCo,
 } from "../internal.js";
-import { Account, CoValueBase, ValueRef, inspect } from "../internal.js";
-import { Schema } from "@effect/schema";
+import {
+    ItemsSym,
+    Account,
+    CoValueBase,
+    Ref,
+    inspect,
+    co,
+    InitValues,
+    SchemaInit,
+    isRefEncoded,
+} from "../internal.js";
+import { encodeSync, decodeSync } from "@effect/schema/Schema";
+
+export type CoStreamEntry<Item> = SingleCoStreamEntry<Item> & {
+    all: IterableIterator<SingleCoStreamEntry<Item>>;
+};
 
-export type CoStreamEntry<Item> = {
+export type SingleCoStreamEntry<Item> = {
     value: NonNullable<Item> extends CoValue ? NonNullable<Item> | null : Item;
-    ref?: NonNullable<Item> extends CoValue
-        ? ValueRef<NonNullable<Item>>
-        : never;
-    by?: Account;
+    ref: NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never;
+    by?: Account | null;
     madeAt: Date;
     tx: CojsonInternalTypes.TransactionID;
 };
 
-export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
+export class CoStream<Item = any>
     extends CoValueBase
     implements CoValue<"CoStream", RawCoStream>
 {
-    id!: ID<this>;
-    _type!: "CoStream";
+    static Of<Item>(item: IfCo<Item, Item>): typeof CoStream<Item> {
+        return class CoStreamOf extends CoStream<Item> {
+            [co.items] = item;
+        };
+    }
+
+    declare id: ID<this>;
+    declare _type: "CoStream";
     static {
         this.prototype._type = "CoStream";
     }
-    _raw!: RawCoStream;
+    declare _raw: RawCoStream;
 
     /** @internal This is only a marker type and doesn't exist at runtime */
-    _item!: Item;
-    static _encoding: any;
-    get _encoding(): {
-        _item: FieldDescriptorFor<Item>;
+    [ItemsSym]!: Item;
+    static _schema: any;
+    get _schema(): {
+        [ItemsSym]: SchemaFor<Item>;
     } {
-        return (this.constructor as typeof CoStream)._encoding;
+        return (this.constructor as typeof CoStream)._schema;
     }
 
-    by: {
-        [key: ID<Account>]: CoStreamEntry<Item>;
-    } = {};
+    [key: ID<Account>]: CoStreamEntry<Item>;
+
     get byMe(): CoStreamEntry<Item> | undefined {
-        return this.by[this._loadedAs.id];
+        return this[this._loadedAs.id];
     }
-    in: {
+    perSession!: {
         [key: SessionID]: CoStreamEntry<Item>;
-    } = {};
+    };
     get inCurrentSession(): CoStreamEntry<Item> | undefined {
-        return this.in[this._loadedAs.sessionID];
+        return this.perSession[this._loadedAs.sessionID];
     }
 
-    constructor(_init: undefined, options: { fromRaw: RawCoStream });
-    constructor(init: Item[], options: { owner: Account | Group });
+    [InitValues]?: any;
+
     constructor(
-        init: Item[] | undefined,
-        options: { owner: Account | Group } | { fromRaw: RawCoStream }
+        options:
+            | { init: Item[]; owner: Account | Group }
+            | { fromRaw: RawCoStream }
     ) {
         super();
 
-        let raw: RawCoStream;
-
         if ("fromRaw" in options) {
-            raw = options.fromRaw;
+            Object.defineProperties(this, {
+                id: {
+                    value: options.fromRaw.id,
+                    enumerable: false,
+                },
+                _raw: { value: options.fromRaw, enumerable: false },
+            });
         } else {
-            const rawOwner = options.owner._raw;
-
-            raw = rawOwner.createStream();
-        }
-
-        Object.defineProperties(this, {
-            id: {
-                value: raw.id,
-                enumerable: false,
-            },
-            _raw: { value: raw, enumerable: false },
-        });
-
-        if (init !== undefined) {
-            for (const item of init) {
-                this.pushItem(item);
-            }
+            this[InitValues] = {
+                init: options.init,
+                owner: options.owner,
+            };
         }
 
-        this.updateEntries();
+        return new Proxy(this, CoStreamProxyHandler as ProxyHandler<this>);
     }
 
-    private updateEntries() {
-        for (const accountID of this._raw.accounts()) {
-            Object.defineProperty(this.by, accountID, {
-                get: () => {
-                    const rawEntry = this._raw.lastItemBy(accountID);
-
-                    if (!rawEntry) return;
-                    return entryFromRawEntry(
-                        this,
-                        rawEntry,
-                        this._loadedAs,
-                        accountID as unknown as ID<Account>,
-                        this._encoding._item
-                    );
-                },
-                configurable: true,
-                enumerable: true,
-            });
-        }
-
-        for (const sessionID of this._raw.sessions()) {
-            Object.defineProperty(this.in, sessionID, {
-                get: () => {
-                    const rawEntry = this._raw.lastItemIn(
-                        sessionID as unknown as SessionID
-                    );
-
-                    if (!rawEntry) return;
-                    const by =
-                        cojsonInternals.accountOrAgentIDfromSessionID(
-                            sessionID
-                        );
-                    return entryFromRawEntry(
-                        this,
-                        rawEntry,
-                        this._loadedAs,
-                        cojsonInternals.isAccountID(by)
-                            ? (by as unknown as ID<Account>)
-                            : undefined,
-                        this._encoding._item
-                    );
-                },
-                configurable: true,
-                enumerable: true,
-            });
-        }
+    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);
         }
-        this.updateEntries();
     }
 
     private pushItem(item: Item) {
-        const itemDescriptor = this._encoding._item as FieldDescriptor;
+        const itemDescriptor = this._schema[ItemsSym] as Schema;
 
         if (itemDescriptor === "json") {
             this._raw.push(item as JsonValue);
         } else if ("encoded" in itemDescriptor) {
-            this._raw.push(Schema.encodeSync(itemDescriptor.encoded)(item));
-        } else if ("ref" in itemDescriptor) {
+            this._raw.push(encodeSync(itemDescriptor.encoded)(item));
+        } else if (isRefEncoded(itemDescriptor)) {
             this._raw.push((item as unknown as CoValue).id);
         }
     }
 
     toJSON() {
-        const itemDescriptor = this._encoding._item as FieldDescriptor;
+        const itemDescriptor = this._schema[ItemsSym] as Schema;
         const mapper =
             itemDescriptor === "json"
                 ? (v: unknown) => v
                 : "encoded" in itemDescriptor
-                  ? Schema.encodeSync(itemDescriptor.encoded)
+                  ? encodeSync(itemDescriptor.encoded)
                   : (v: unknown) => v && (v as CoValue).id;
 
         return {
             id: this.id,
             _type: this._type,
-            by: Object.fromEntries(
-                Object.entries(this.by).map(([account, entry]) => [
+            ...Object.fromEntries(
+                Object.entries(this).map(([account, entry]) => [
                     account,
                     mapper(entry.value),
                 ])
             ),
             in: Object.fromEntries(
-                Object.entries(this.in).map(([session, entry]) => [
+                Object.entries(this.perSession).map(([session, entry]) => [
                     session,
                     mapper(entry.value),
                 ])
@@ -197,12 +167,12 @@ export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
         return this.toJSON();
     }
 
-    static encoding<V extends CoStream>(
+    static schema<V extends CoStream>(
         this: { new (...args: any): V } & typeof CoStream,
-        def: { _item: V["_encoding"]["_item"] }
+        def: { [ItemsSym]: V["_schema"][ItemsSym] }
     ) {
-        this._encoding ||= {};
-        Object.assign(this._encoding, def);
+        this._schema ||= {};
+        Object.assign(this._schema, def);
     }
 }
 
@@ -216,32 +186,48 @@ function entryFromRawEntry<Item>(
     },
     loadedAs: Account & Me,
     accountID: ID<Account> | undefined,
-    itemField: FieldDescriptor
-) {
+    itemField: Schema
+): Omit<CoStreamEntry<Item>, "all"> {
     return {
-        get value(): Item | undefined {
+        get value(): NonNullable<Item> extends CoValue
+            ? (CoValue & Item) | null
+            : Item {
             if (itemField === "json") {
-                return rawEntry.value as Item;
+                return rawEntry.value as NonNullable<Item> extends CoValue
+                    ? (CoValue & Item) | null
+                    : Item;
             } else if ("encoded" in itemField) {
-                return Schema.decodeSync(itemField.encoded)(rawEntry.value);
-            } else if ("ref" in itemField) {
-                return this.ref?.accessFrom(accessFrom) as Item;
+                return decodeSync(itemField.encoded)(rawEntry.value);
+            } else if (isRefEncoded(itemField)) {
+                return this.ref?.accessFrom(
+                    accessFrom
+                ) as NonNullable<Item> extends CoValue
+                    ? (CoValue & Item) | null
+                    : Item;
+            } else {
+                throw new Error("Invalid item field schema");
             }
         },
-        get ref() {
-            if (itemField !== "json" && "ref" in itemField) {
+        get ref(): NonNullable<Item> extends CoValue
+            ? Ref<NonNullable<Item>>
+            : never {
+            if (itemField !== "json" && isRefEncoded(itemField)) {
                 const rawId = rawEntry.value;
-                return new ValueRef(
+                return new Ref(
                     rawId as unknown as ID<CoValue>,
                     loadedAs,
-                    itemField.ref()
-                );
+                    itemField
+                ) as NonNullable<Item> extends CoValue
+                    ? Ref<NonNullable<Item>>
+                    : never;
+            } else {
+                return undefined as never;
             }
         },
         get by() {
             return (
                 accountID &&
-                new ValueRef(
+                new Ref<Account>(
                     accountID as unknown as ID<Account>,
                     loadedAs,
                     Account
@@ -253,16 +239,196 @@ function entryFromRawEntry<Item>(
     };
 }
 
+function init(stream: CoStream) {
+    const init = stream[InitValues];
+    if (!init) return;
+
+    const raw = init.owner._raw.createStream();
+
+    Object.defineProperties(stream, {
+        id: {
+            value: raw.id,
+            enumerable: false,
+        },
+        _raw: { value: raw, enumerable: false },
+    });
+
+    if (init.init) {
+        stream.push(...init.init);
+    }
+
+    delete stream[InitValues];
+}
+
+export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
+    get(target, key, receiver) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            const rawEntry = target._raw.lastItemBy(key as AccountID);
+
+            if (!rawEntry) return;
+            const entry = entryFromRawEntry(
+                receiver,
+                rawEntry,
+                target._loadedAs,
+                key as unknown as ID<Account>,
+                target._schema[ItemsSym]
+            );
+
+            Object.defineProperty(entry, "all", {
+                get: () => {
+                    const allRawEntries = target._raw.itemsBy(key as AccountID);
+                    return (function* () {
+                        while (true) {
+                            const rawEntry = allRawEntries.next();
+                            if (rawEntry.done) return;
+                            yield entryFromRawEntry(
+                                receiver,
+                                rawEntry.value,
+                                target._loadedAs,
+                                key as unknown as ID<Account>,
+                                target._schema[ItemsSym]
+                            );
+                        }
+                    })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
+                },
+            });
+
+            return entry;
+        } else if (key === "perSession") {
+            return new Proxy(
+                {},
+                CoStreamPerSessionProxyHandler(target, receiver)
+            );
+        } else {
+            return Reflect.get(target, key, receiver);
+        }
+    },
+    set(target, key, value, receiver) {
+        if (
+            key === ItemsSym &&
+            typeof value === "object" &&
+            SchemaInit in value
+        ) {
+            (target.constructor as typeof CoStream)._schema ||= {};
+            (target.constructor as typeof CoStream)._schema[ItemsSym] =
+                value[SchemaInit];
+            init(target);
+            return true;
+        } else {
+            return Reflect.set(target, key, value, receiver);
+        }
+    },
+    defineProperty(target, key, descriptor) {
+        if (
+            descriptor.value &&
+            key === ItemsSym &&
+            typeof descriptor.value === "object" &&
+            SchemaInit in descriptor.value
+        ) {
+            (target.constructor as typeof CoStream)._schema ||= {};
+            (target.constructor as typeof CoStream)._schema[ItemsSym] =
+                descriptor.value[SchemaInit];
+            init(target);
+            return true;
+        } else {
+            return Reflect.defineProperty(target, key, descriptor);
+        }
+    },
+    ownKeys(target) {
+        const keys = Reflect.ownKeys(target);
+
+        for (const accountID of target._raw.accounts()) {
+            keys.push(accountID);
+        }
+
+        return keys;
+    },
+    getOwnPropertyDescriptor(target, key) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: false,
+            };
+        } else {
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        }
+    },
+};
+
+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;
+            const rawEntry = innerTarget._raw.lastItemIn(sessionID);
+
+            if (!rawEntry) return;
+            const by = cojsonInternals.accountOrAgentIDfromSessionID(sessionID);
+
+            const entry = entryFromRawEntry(
+                accessFrom,
+                rawEntry,
+                innerTarget._loadedAs,
+                cojsonInternals.isAccountID(by)
+                    ? (by as unknown as ID<Account>)
+                    : undefined,
+                innerTarget._schema[ItemsSym]
+            );
+
+            Object.defineProperty(entry, "all", {
+                get: () => {
+                    const allRawEntries = innerTarget._raw.itemsIn(sessionID);
+                    return (function* () {
+                        while (true) {
+                            const rawEntry = allRawEntries.next();
+                            if (rawEntry.done) return;
+                            yield entryFromRawEntry(
+                                accessFrom,
+                                rawEntry.value,
+                                innerTarget._loadedAs,
+                                cojsonInternals.isAccountID(by)
+                                    ? (by as unknown as ID<Account>)
+                                    : undefined,
+                                innerTarget._schema[ItemsSym]
+                            );
+                        }
+                    })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
+                },
+            });
+
+            return entry;
+        } else {
+            return Reflect.get(innerTarget, key, receiver);
+        }
+    },
+    ownKeys() {
+        return innerTarget._raw.sessions();
+    },
+    getOwnPropertyDescriptor(target, key) {
+        if (typeof key === "string" && key.startsWith("co_")) {
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: false,
+            };
+        } else {
+            return Reflect.getOwnPropertyDescriptor(target, key);
+        }
+    },
+});
+
 export class BinaryCoStream
     extends CoValueBase
     implements CoValue<"BinaryCoStream", RawBinaryCoStream>
 {
-    id!: ID<this>;
-    _type!: "BinaryCoStream";
-    _raw!: RawBinaryCoStream;
+    declare id: ID<this>;
+    declare _type: "BinaryCoStream";
+    declare _raw: RawBinaryCoStream;
 
     constructor(
-        init: [] | undefined,
         options:
             | {
                   owner: Account | Group;
@@ -291,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

@@ -1,28 +1,31 @@
 import {
     BinaryCoStream,
     CoMap,
-    indexSignature,
+    co,
     subscriptionsScopes,
 } from "../../internal.js";
 
-export class ImageDefinition extends CoMap<ImageDefinition> {
-    declare originalSize: [number, number];
-    declare placeholderDataURL?: string;
+export class ImageDefinition extends CoMap {
+    originalSize = co.json<[number, number]>();
+    placeholderDataURL? = co.string;
 
-    [res: `${number}x${number}`]: BinaryCoStream | null;
-    declare [indexSignature]: BinaryCoStream | null;
+    [co.items] = co.ref(BinaryCoStream);
+    [res: `${number}x${number}`]: co<BinaryCoStream | null>;
 
-    get _highestResAvailable():
-        | { res: `${number}x${number}`; stream: BinaryCoStream }
-        | undefined {
+    highestResAvailable(options?: {
+        maxWidth?: number;
+    }): { res: `${number}x${number}`; stream: BinaryCoStream } | undefined {
         if (!subscriptionsScopes.get(this)) {
             console.warn(
                 "highestResAvailable() only makes sense when used within a subscription."
             );
         }
 
-        const resolutions = Object.keys(this).filter((key) =>
-            key.match(/^\d+x\d+$/)
+        const resolutions = Object.keys(this).filter(
+            (key) =>
+                key.match(/^\d+x\d+$/) &&
+                (!options?.maxWidth ||
+                    Number(key.split("x")[0]) <= options.maxWidth)
         ) as `${number}x${number}`[];
 
         resolutions.sort((a, b) => {
@@ -53,8 +56,3 @@ export class ImageDefinition extends CoMap<ImageDefinition> {
         );
     }
 }
-ImageDefinition.encoding({
-    originalSize: "json",
-    placeholderDataURL: "json",
-    [indexSignature]: { ref: () => BinaryCoStream },
-});