jazz-tools 0.7.0-alpha.0 → 0.7.0-alpha.2

package/src/coValues/coStream.ts

@@ -0,0 +1,325 @@
+import type {
+    AccountID,
+    AgentID,
+    BinaryStreamInfo,
+    CojsonInternalTypes,
+    JsonValue,
+    RawBinaryCoStream,
+    RawCoStream,
+    SessionID,
+} from "cojson";
+import { cojsonInternals } from "cojson";
+import type {
+    CoValue,
+    EnsureItemNullable,
+    FieldDescriptor,
+    FieldDescriptorFor,
+    Group,
+    ID,
+    Me,
+} from "../internal.js";
+import { Account, CoValueBase, ValueRef, inspect } from "../internal.js";
+import { Schema } from "@effect/schema";
+
+export type CoStreamEntry<Item> = {
+    value: NonNullable<Item> extends CoValue ? NonNullable<Item> | null : Item;
+    ref?: NonNullable<Item> extends CoValue
+        ? ValueRef<NonNullable<Item>>
+        : never;
+    by?: Account;
+    madeAt: Date;
+    tx: CojsonInternalTypes.TransactionID;
+};
+
+export class CoStream<Item extends EnsureItemNullable<Item, "Co.Stream"> = any>
+    extends CoValueBase
+    implements CoValue<"CoStream", RawCoStream>
+{
+    id!: ID<this>;
+    _type!: "CoStream";
+    static {
+        this.prototype._type = "CoStream";
+    }
+    _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>;
+    } {
+        return (this.constructor as typeof CoStream)._encoding;
+    }
+
+    by: {
+        [key: ID<Account>]: CoStreamEntry<Item>;
+    } = {};
+    get byMe(): CoStreamEntry<Item> | undefined {
+        return this.by[this._loadedAs.id];
+    }
+    in: {
+        [key: SessionID]: CoStreamEntry<Item>;
+    } = {};
+    get inCurrentSession(): CoStreamEntry<Item> | undefined {
+        return this.in[this._loadedAs.sessionID];
+    }
+
+    constructor(_init: undefined, options: { fromRaw: RawCoStream });
+    constructor(init: Item[], options: { owner: Account | Group });
+    constructor(
+        init: Item[] | undefined,
+        options: { owner: Account | Group } | { fromRaw: RawCoStream }
+    ) {
+        super();
+
+        let raw: RawCoStream;
+
+        if ("fromRaw" in options) {
+            raw = options.fromRaw;
+        } 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.updateEntries();
+    }
+
+    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,
+            });
+        }
+    }
+
+    push(...items: Item[]) {
+        for (const item of items) {
+            this.pushItem(item);
+        }
+        this.updateEntries();
+    }
+
+    private pushItem(item: Item) {
+        const itemDescriptor = this._encoding._item as FieldDescriptor;
+
+        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((item as unknown as CoValue).id);
+        }
+    }
+
+    toJSON() {
+        const itemDescriptor = this._encoding._item as FieldDescriptor;
+        const mapper =
+            itemDescriptor === "json"
+                ? (v: unknown) => v
+                : "encoded" in itemDescriptor
+                  ? Schema.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]) => [
+                    account,
+                    mapper(entry.value),
+                ])
+            ),
+            in: Object.fromEntries(
+                Object.entries(this.in).map(([session, entry]) => [
+                    session,
+                    mapper(entry.value),
+                ])
+            ),
+        };
+    }
+
+    [inspect]() {
+        return this.toJSON();
+    }
+
+    static encoding<V extends CoStream>(
+        this: { new (...args: any): V } & typeof CoStream,
+        def: { _item: V["_encoding"]["_item"] }
+    ) {
+        this._encoding ||= {};
+        Object.assign(this._encoding, def);
+    }
+}
+
+function entryFromRawEntry<Item>(
+    accessFrom: CoValue,
+    rawEntry: {
+        by: AccountID | AgentID;
+        tx: CojsonInternalTypes.TransactionID;
+        at: Date;
+        value: JsonValue;
+    },
+    loadedAs: Account & Me,
+    accountID: ID<Account> | undefined,
+    itemField: FieldDescriptor
+) {
+    return {
+        get value(): Item | undefined {
+            if (itemField === "json") {
+                return rawEntry.value as 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;
+            }
+        },
+        get ref() {
+            if (itemField !== "json" && "ref" in itemField) {
+                const rawId = rawEntry.value;
+                return new ValueRef(
+                    rawId as unknown as ID<CoValue>,
+                    loadedAs,
+                    itemField.ref()
+                );
+            }
+        },
+        get by() {
+            return (
+                accountID &&
+                new ValueRef(
+                    accountID as unknown as ID<Account>,
+                    loadedAs,
+                    Account
+                )?.accessFrom(accessFrom)
+            );
+        },
+        madeAt: rawEntry.at,
+        tx: rawEntry.tx,
+    };
+}
+
+export class BinaryCoStream
+    extends CoValueBase
+    implements CoValue<"BinaryCoStream", RawBinaryCoStream>
+{
+    id!: ID<this>;
+    _type!: "BinaryCoStream";
+    _raw!: RawBinaryCoStream;
+
+    constructor(
+        init: [] | undefined,
+        options:
+            | {
+                  owner: Account | Group;
+              }
+            | {
+                  fromRaw: RawBinaryCoStream;
+              }
+    ) {
+        super();
+
+        let raw: RawBinaryCoStream;
+
+        if ("fromRaw" in options) {
+            raw = options.fromRaw;
+        } else {
+            const rawOwner = options.owner._raw;
+            raw = rawOwner.createBinaryStream();
+        }
+
+        Object.defineProperties(this, {
+            id: {
+                value: raw.id,
+                enumerable: false,
+            },
+            _raw: { value: raw, enumerable: false },
+        });
+    }
+
+    getChunks(options?: {
+        allowUnfinished?: boolean;
+    }):
+        | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
+        | undefined {
+        return this._raw.getBinaryChunks(options?.allowUnfinished);
+    }
+
+    start(options: BinaryStreamInfo): void {
+        this._raw.startBinaryStream(options);
+    }
+
+    push(data: Uint8Array): void {
+        this._raw.pushBinaryStreamChunk(data);
+    }
+
+    end(): void {
+        this._raw.endBinaryStream();
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            _type: this._type,
+            ...this.getChunks(),
+        };
+    }
+
+    [inspect]() {
+        return this.toJSON();
+    }
+}

package/src/coValues/extensions/imageDef.ts

@@ -1,20 +1,18 @@
-import * as S from "@effect/schema/Schema";
-import { CoMapOf } from "../coMap/coMapOf.js";
-import { BinaryCoStreamImpl } from "../coStream/coStreamOf.js";
-import { BinaryCoStream } from "../coStream/coStream.js";
-import { subscriptionsScopes } from "../../subscriptionScope.js";
+import {
+    BinaryCoStream,
+    CoMap,
+    indexSignature,
+    subscriptionsScopes,
+} from "../../internal.js";
 
-export class ImageDefinition extends CoMapOf(
-    {
-        originalSize: S.tuple(S.number, S.number),
-        placeholderDataURL: S.optional(S.string),
-    },
-    {
-        key: S.templateLiteral(S.string, S.literal("x"), S.string),
-        value: BinaryCoStreamImpl,
-    }
-).as<ImageDefinition>() {
-    get highestResAvailable():
+export class ImageDefinition extends CoMap<ImageDefinition> {
+    declare originalSize: [number, number];
+    declare placeholderDataURL?: string;
+
+    [res: `${number}x${number}`]: BinaryCoStream | null;
+    declare [indexSignature]: BinaryCoStream | null;
+
+    get _highestResAvailable():
         | { res: `${number}x${number}`; stream: BinaryCoStream }
         | undefined {
         if (!subscriptionsScopes.get(this)) {
@@ -47,5 +45,16 @@ export class ImageDefinition extends CoMapOf(
                 );
             }
         }
+        return (
+            highestAvailableResolution && {
+                res: highestAvailableResolution,
+                stream: this[highestAvailableResolution]!,
+            }
+        );
     }
 }
+ImageDefinition.encoding({
+    originalSize: "json",
+    placeholderDataURL: "json",
+    [indexSignature]: { ref: () => BinaryCoStream },
+});

package/src/coValues/group.ts

@@ -0,0 +1,186 @@
+import type { CoID, Everyone, RawCoMap, RawGroup, Role } from "cojson";
+import type {
+    CoValue,
+    CoValueClass,
+    ID,
+    PrimitiveField,
+    RefField,
+} from "../internal.js";
+import {
+    Account,
+    CoMap,
+    CoValueBase,
+    ValueRef,
+    isControlledAccount,
+} from "../internal.js";
+
+export class Profile extends CoMap<{ name: string }> {
+    declare name: string;
+}
+Profile.encoding({ name: "json" });
+
+export class Group<
+        Def extends { profile: Profile | null; root: CoMap | null } = {
+            profile: Profile | null;
+            root: CoMap | null;
+        },
+    >
+    extends CoValueBase
+    implements CoValue<"Group", RawGroup>
+{
+    id!: ID<this>;
+    _type!: "Group";
+    static {
+        this.prototype._type = "Group";
+    }
+    _raw!: RawGroup;
+
+    static _encoding: any;
+    get _encoding(): {
+        profile: Def["profile"] extends CoValue
+            ? RefField<Def["profile"]>
+            : PrimitiveField;
+        root: Def["root"] extends CoValue
+            ? RefField<Def["root"]>
+            : PrimitiveField;
+    } {
+        return (this.constructor as typeof Group)._encoding;
+    }
+    static {
+        this._encoding = {
+            profile: { json: true },
+            root: { json: true },
+        } as any;
+        Object.defineProperty(this.prototype, "_encoding", {
+            get: () => this._encoding,
+        });
+    }
+
+    profile!: Def["profile"] extends Profile
+        ? Def["profile"] | null
+        : undefined;
+
+    root!: Def["root"] extends CoMap ? Def["root"] | null : undefined;
+
+    get _refs(): {
+        profile: Def["profile"] extends Profile
+            ? ValueRef<Def["profile"]>
+            : never;
+        root: Def["root"] extends CoMap ? ValueRef<Def["root"]> : never;
+    } {
+        const profileID = this._raw.get("profile") as unknown as
+            | ID<NonNullable<Def["profile"]>>
+            | undefined;
+        const rootID = this._raw.get("root") as unknown as
+            | ID<NonNullable<Def["root"]>>
+            | undefined;
+        return {
+            profile:
+                profileID &&
+                (new ValueRef(
+                    profileID,
+                    this._loadedAs,
+                    (
+                        this._encoding.profile as RefField<
+                            NonNullable<Def["profile"]>
+                        >
+                    ).ref()
+                ) as any),
+            root:
+                rootID &&
+                (new ValueRef(
+                    rootID,
+                    this._loadedAs,
+                    (
+                        this._encoding.root as RefField<
+                            NonNullable<Def["root"]>
+                        >
+                    ).ref()
+                ) as any),
+        };
+    }
+
+    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 }
+    ) {
+        super();
+        let raw: RawGroup;
+
+        if (options && "fromRaw" in options) {
+            raw = options.fromRaw;
+        } else {
+            const initOwner = options?.owner || init?.owner;
+            if (!initOwner) throw new Error("No owner provided");
+            if (
+                initOwner instanceof Account &&
+                isControlledAccount(initOwner)
+            ) {
+                const rawOwner = initOwner._raw;
+                raw = rawOwner.createGroup();
+            } else {
+                throw new Error(
+                    "Can only construct group as a controlled account"
+                );
+            }
+        }
+
+        Object.defineProperties(this, {
+            id: {
+                value: raw.id,
+                enumerable: false,
+            },
+            _raw: { value: raw, enumerable: false },
+            profile: {
+                get: () => {
+                    const ref = this._refs.profile;
+                    return ref ? ref.accessFrom(this) : (undefined as any);
+                },
+                set: (value: Def["profile"] | null) => {
+                    if (value) {
+                        this._raw.set(
+                            "profile",
+                            value.id as unknown as CoID<RawCoMap>
+                        );
+                    }
+                },
+            },
+            root: {
+                get: () => {
+                    const ref = this._refs.root;
+                    return ref ? ref.accessFrom(this) : (undefined as any);
+                },
+                set: (value: Def["root"] | null) => {
+                    if (value) {
+                        this._raw.set(
+                            "root",
+                            value.id as unknown as CoID<RawCoMap>
+                        );
+                    }
+                },
+            },
+        });
+    }
+
+    myRole(): Role | undefined {
+        return this._raw.myRole();
+    }
+
+    addMember(member: Everyone | Account, role: Role) {
+        this._raw.addMember(member === "everyone" ? member : member._raw, role);
+    }
+
+    static define<V extends Account>(
+        this: CoValueClass<V> & typeof Account,
+        fields: {
+            profile: V["_encoding"]["profile"];
+            root: V["_encoding"]["root"];
+        }
+    ) {
+        this._encoding ||= {};
+        Object.assign(this._encoding, fields);
+    }
+}