jazz-tools 0.7.0-alpha.4 → 0.7.0-alpha.41

package/src/coValues/deepLoading.ts

@@ -0,0 +1,215 @@
+import { SessionID } from "cojson";
+import {
+    Account,
+    CoList,
+    CoStream,
+    CoStreamEntry,
+    ItemsSym,
+    Ref,
+    UnCo,
+} from "../internal.js";
+import { CoKeys } from "./coMap.js";
+import { CoValue, ID } from "./interfaces.js";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fulfillsDepth(depth: any, value: CoValue): boolean {
+    if (
+        value._type === "CoMap" ||
+        value._type === "Group" ||
+        value._type === "Account"
+    ) {
+        if (Array.isArray(depth) && depth.length === 1) {
+            return Object.entries(value).every(([key, item]) => {
+                return (
+                    value as unknown as {
+                        _refs: { [key: string]: Ref<CoValue> | undefined };
+                    }
+                )._refs[key]
+                    ? item && fulfillsDepth(depth[0], item)
+                    : true;
+            });
+        } else {
+            for (const key of Object.keys(depth)) {
+                const map = value as unknown as {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    [key: string]: any;
+                    _refs: { [key: string]: Ref<CoValue> | undefined };
+                };
+                if (!map._refs[key]) {
+                    continue;
+                }
+                if (!map[key]) {
+                    return false;
+                }
+                if (!fulfillsDepth(depth[key], map[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    } else if (value._type === "CoList") {
+        if (depth.length === 0) {
+            return true;
+        } else {
+            const itemDepth = depth[0];
+            return (value as CoList).every((item, i) =>
+                (value as CoList)._refs[i]
+                    ? item && fulfillsDepth(itemDepth, item)
+                    : true,
+            );
+        }
+    } else if (value._type === "CoStream") {
+        if (depth.length === 0) {
+            return true;
+        } else {
+            const itemDepth = depth[0];
+            return Object.values((value as CoStream).perSession).every(
+                (entry) => entry.value && fulfillsDepth(itemDepth, entry.value),
+            );
+        }
+    } else if (value._type === "BinaryCoStream") {
+        return true;
+    } else {
+        console.error(value);
+        throw new Error("Unexpected value type: " + value._type);
+    }
+}
+
+type UnCoNotNull<T> = UnCo<Exclude<T, null>>;
+type Clean<T> = UnCo<NonNullable<T>>;
+
+export type DepthsIn<
+    V,
+    DepthLimit extends number = 5,
+    CurrentDepth extends number[] = [],
+> =
+    | (DepthLimit extends CurrentDepth["length"]
+          ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            any
+          : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
+            V extends Array<infer Item>
+            ?
+                  | [
+                        DepthsIn<
+                            UnCoNotNull<Item>,
+                            DepthLimit,
+                            [0, ...CurrentDepth]
+                        >,
+                    ]
+                  | never[]
+            : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
+              V extends { _type: "CoMap" | "Group" | "Account" }
+              ?
+                    | {
+                          [Key in CoKeys<V> as Clean<V[Key]> extends CoValue
+                              ? Key
+                              : never]?: DepthsIn<
+                              Clean<V[Key]>,
+                              DepthLimit,
+                              [0, ...CurrentDepth]
+                          >;
+                      }
+                    | (ItemsSym extends keyof V
+                          ? [
+                                DepthsIn<
+                                    Clean<V[ItemsSym]>,
+                                    DepthLimit,
+                                    [0, ...CurrentDepth]
+                                >,
+                            ]
+                          : never)
+                    | never[]
+              : V extends {
+                      _type: "CoStream";
+                      byMe: CoStreamEntry<infer Item> | undefined;
+                  }
+                ?
+                      | [
+                            DepthsIn<
+                                UnCoNotNull<Item>,
+                                DepthLimit,
+                                [0, ...CurrentDepth]
+                            >,
+                        ]
+                      | never[]
+                : never[])
+    | never[];
+
+export type DeeplyLoaded<
+    V,
+    Depth,
+    DepthLimit extends number = 5,
+    CurrentDepth extends number[] = [],
+> = DepthLimit extends CurrentDepth["length"]
+    ? V
+    : // Basically V extends CoList - but if we used that we'd introduce circularity into the definition of CoList itself
+      [V] extends [Array<infer Item>]
+      ? Depth extends never[] // []
+          ? V
+          : UnCoNotNull<Item> extends CoValue
+            ? Depth extends Array<infer ItemDepth> // [item-depth]
+                ? (UnCoNotNull<Item> &
+                      DeeplyLoaded<
+                          UnCoNotNull<Item>,
+                          ItemDepth,
+                          DepthLimit,
+                          [0, ...CurrentDepth]
+                      >)[] &
+                      V
+                : never
+            : V
+      : // Basically V extends CoMap | Group | Account - but if we used that we'd introduce circularity into the definition of CoMap itself
+        [V] extends [{ _type: "CoMap" | "Group" | "Account" }]
+        ? Depth extends never[]
+            ? V
+            : Depth extends Array<infer ItemDepth>
+              ? ItemsSym extends keyof V
+                  ? V & {
+                        [key: string]: DeeplyLoaded<
+                            Clean<V[ItemsSym]>,
+                            ItemDepth,
+                            DepthLimit,
+                            [0, ...CurrentDepth]
+                        >;
+                    }
+                  : never
+              : keyof Depth extends never
+                ? V
+                : {
+                      [Key in keyof Depth]-?: Key extends CoKeys<V>
+                          ? Clean<V[Key]> extends CoValue
+                              ?
+                                    | DeeplyLoaded<
+                                          Clean<V[Key]>,
+                                          Depth[Key],
+                                          DepthLimit,
+                                          [0, ...CurrentDepth]
+                                      >
+                                    | (undefined extends V[Key]
+                                          ? undefined
+                                          : never)
+                              : never
+                          : never;
+                  } & V
+        : [V] extends [
+                {
+                    _type: "CoStream";
+                    byMe: CoStreamEntry<infer Item> | undefined;
+                },
+            ]
+          ? Depth extends never[]
+              ? V
+              : V & {
+                    byMe?: { value: UnCoNotNull<Item> };
+                    inCurrentSession?: { value: UnCoNotNull<Item> };
+                    perSession: {
+                        [key: SessionID]: { value: UnCoNotNull<Item> };
+                    };
+                } & { [key: ID<Account>]: { value: UnCoNotNull<Item> } }
+          : [V] extends [
+                  {
+                      _type: "BinaryCoStream";
+                  },
+              ]
+            ? V
+            : never;

package/src/coValues/extensions/imageDef.ts

@@ -1,28 +1,32 @@
 import {
     BinaryCoStream,
     CoMap,
-    indexSignature,
+    co,
     subscriptionsScopes,
 } from "../../internal.js";
 
-export class ImageDefinition extends CoMap<ImageDefinition> {
-    declare originalSize: [number, number];
-    declare placeholderDataURL?: string;
+/** @category Media */
+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."
+                "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 === undefined ||
+                    Number(key.split("x")[0]) <= options.maxWidth),
         ) as `${number}x${number}`[];
 
         resolutions.sort((a, b) => {
@@ -53,8 +57,3 @@ export class ImageDefinition extends CoMap<ImageDefinition> {
         );
     }
 }
-ImageDefinition.encoding({
-    originalSize: "json",
-    placeholderDataURL: "json",
-    [indexSignature]: { ref: () => BinaryCoStream },
-});

package/src/coValues/group.ts

@@ -1,119 +1,97 @@
-import type { CoID, Everyone, RawCoMap, RawGroup, Role } from "cojson";
-import type {
-    CoValue,
-    CoValueClass,
-    ID,
-    PrimitiveField,
-    RefField,
-} from "../internal.js";
+import type { AccountID, Everyone, RawGroup, Role } from "cojson";
+import type { CoValue, ID, RefEncoded, Schema, ClassOf } from "../internal.js";
 import {
     Account,
     CoMap,
     CoValueBase,
-    ValueRef,
+    Ref,
+    co,
     isControlledAccount,
+    AccountAndGroupProxyHandler,
+    MembersSym,
 } from "../internal.js";
 
-export class Profile extends CoMap<{ name: string }> {
-    declare name: string;
+/** @category Identity & Permissions */
+export class Profile extends CoMap {
+    name = co.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";
+/** @category Identity & Permissions */
+export class Group extends CoValueBase implements CoValue<"Group", RawGroup> {
+    declare id: ID<this>;
+    declare _type: "Group";
     static {
         this.prototype._type = "Group";
     }
-    _raw!: RawGroup;
+    declare _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;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static _schema: any;
+    get _schema(): {
+        profile: Schema;
+        root: Schema;
+        [MembersSym]: RefEncoded<Account>;
     } {
-        return (this.constructor as typeof Group)._encoding;
+        return (this.constructor as typeof Group)._schema;
     }
     static {
-        this._encoding = {
-            profile: { json: true },
-            root: { json: true },
+        this._schema = {
+            profile: "json" satisfies Schema,
+            root: "json" satisfies Schema,
+            [MembersSym]: () => Account satisfies Schema,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         } as any;
-        Object.defineProperty(this.prototype, "_encoding", {
-            get: () => this._encoding,
+        Object.defineProperty(this.prototype, "_schema", {
+            get: () => this._schema,
         });
     }
 
-    profile!: Def["profile"] extends Profile
-        ? Def["profile"] | null
-        : undefined;
-
-    root!: Def["root"] extends CoMap ? Def["root"] | null : undefined;
+    declare profile: Profile | null;
+    declare root: CoMap | null;
+    declare [MembersSym]: Account | null;
 
-    get _refs(): {
-        profile: Def["profile"] extends Profile
-            ? ValueRef<Def["profile"]>
-            : never;
-        root: Def["root"] extends CoMap ? ValueRef<Def["root"]> : never;
-    } {
+    get _refs() {
         const profileID = this._raw.get("profile") as unknown as
-            | ID<NonNullable<Def["profile"]>>
+            | ID<NonNullable<this["profile"]>>
             | undefined;
         const rootID = this._raw.get("root") as unknown as
-            | ID<NonNullable<Def["root"]>>
+            | ID<NonNullable<this["root"]>>
             | undefined;
         return {
             profile:
                 profileID &&
-                (new ValueRef(
+                (new Ref(
                     profileID,
                     this._loadedAs,
-                    (
-                        this._encoding.profile as RefField<
-                            NonNullable<Def["profile"]>
-                        >
-                    ).ref()
-                ) as any),
+                    this._schema.profile as RefEncoded<
+                        NonNullable<this["profile"]>
+                    >,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any as this["profile"] extends Profile
+                    ? Ref<this["profile"]>
+                    : never),
             root:
                 rootID &&
-                (new ValueRef(
+                (new Ref(
                     rootID,
                     this._loadedAs,
-                    (
-                        this._encoding.root as RefField<
-                            NonNullable<Def["root"]>
-                        >
-                    ).ref()
-                ) as any),
+                    this._schema.root as RefEncoded<NonNullable<this["root"]>>,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any as this["root"] extends CoMap
+                    ? Ref<this["root"]>
+                    : never),
         };
     }
 
-    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 }
-    ) {
+    /** @deprecated Don't use constructor directly, use .create */
+    constructor(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;
+            const initOwner = options.owner;
             if (!initOwner) throw new Error("No owner provided");
             if (
                 initOwner instanceof Account &&
@@ -123,7 +101,7 @@ export class Group<
                 raw = rawOwner.createGroup();
             } else {
                 throw new Error(
-                    "Can only construct group as a controlled account"
+                    "Can only construct group as a controlled account",
                 );
             }
         }
@@ -134,35 +112,19 @@ export class Group<
                 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>
-                        );
-                    }
-                },
-            },
         });
+
+        return new Proxy(
+            this,
+            AccountAndGroupProxyHandler as ProxyHandler<this>,
+        );
+    }
+
+    static create<G extends Group>(
+        this: ClassOf<G>,
+        options: { owner: Account },
+    ) {
+        return new this(options);
     }
 
     myRole(): Role | undefined {
@@ -171,16 +133,38 @@ export class Group<
 
     addMember(member: Everyone | Account, role: Role) {
         this._raw.addMember(member === "everyone" ? member : member._raw, role);
+        return this;
     }
 
-    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);
+    get members() {
+        return this._raw
+            .keys()
+            .filter((key) => {
+                return key === "everyone" || key.startsWith("co_");
+            })
+            .map((id) => {
+                const role = this._raw.get(id as Everyone | AccountID);
+                const accountID =
+                    id === "everyone"
+                        ? undefined
+                        : (id as unknown as ID<Account>);
+                const ref =
+                    accountID &&
+                    new Ref<NonNullable<this[MembersSym]>>(
+                        accountID,
+                        this._loadedAs,
+                        this._schema[MembersSym],
+                    );
+                const accessRef = () => ref?.accessFrom(this, "members." + id);
+
+                return {
+                    id: id as unknown as Everyone | ID<this[MembersSym]>,
+                    role,
+                    ref,
+                    get account() {
+                        return accessRef();
+                    },
+                };
+            });
     }
 }