jazz-tools 0.7.0-alpha.9 → 0.7.1

package/src/coValues/interfaces.ts

@@ -1,7 +1,7 @@
-import { Effect, Sink, Stream } from "effect";
+import { Effect, Option, Sink, Stream } from "effect";
 import type { CojsonInternalTypes, RawCoValue } from "cojson";
 import { RawAccount } from "cojson";
-import type { Me, UnavailableError } from "../internal.js";
+import type { DeeplyLoaded, DepthsIn, UnavailableError } from "../internal.js";
 import {
     Account,
     AccountCtx,
@@ -9,200 +9,290 @@ import {
     SubscriptionScope,
     Ref,
     inspect,
+    subscriptionsScopes,
 } from "../internal.js";
+import { fulfillsDepth } from "./deepLoading.js";
 
-export type SubclassedConstructor<T> = {
+export type ClassOf<T> = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     new (...args: any[]): T;
 };
 
+/** @category Abstract interfaces */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
-    /** @category Construction and loading */
     new (init: Init, options: { owner: Account | Group }): Value;
 
     /** @ignore */
     fromRaw(raw: Value["_raw"]): Value;
 
-    /** @category Construction and loading */
-    load<V extends Value>(
-        this: SubclassedConstructor<V>,
+    /** @category Subscription & Loading */
+    load<V extends Value, Depth>(
+        this: ClassOf<V>,
         id: ID<V>,
-        options: {
-            as: Account & Me;
-            onProgress?: (progress: number) => void;
-        }
-    ): Promise<V | undefined>;
+        as: Account,
+        depth: Depth & DepthsIn<V>,
+    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
+    /** @category Subscription & Loading */
+    load<V extends Value, Depth>(
+        this: ClassOf<V>,
+        existing: V,
+        depth: Depth & DepthsIn<V>,
+    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
 
-    /** @category Construction and loading */
-    loadEf<V extends Value>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>
-    ): Effect.Effect<V, UnavailableError, AccountCtx>;
+    /** @category Subscription & Loading */
+    loadEf<V extends Value, Depth>(
+        this: ClassOf<V>,
+        id: ID<V>,
+        depth: Depth & DepthsIn<V>,
+    ): Effect.Effect<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx>;
 
-    /** @category Subscription */
-    subscribe<V extends Value, Acc extends Account>(
-        this: SubclassedConstructor<V>,
+    /** @category Subscription & Loading */
+    subscribe<V extends Value, Depth>(
+        this: ClassOf<V>,
         id: ID<V>,
-        options: { as: Acc & Me },
-        onUpdate: (value: V) => void
+        as: Account,
+        depth: Depth & DepthsIn<V>,
+        listener: (value: DeeplyLoaded<V, Depth>) => void,
+    ): () => void;
+    subscribe<V extends Value, Depth>(
+        this: ClassOf<V>,
+        existing: V,
+        depth: Depth & DepthsIn<V>,
+        listener: (value: DeeplyLoaded<V, Depth>) => void,
     ): () => void;
 
-    /** @category Subscription */
-    subscribeEf<V extends Value>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>
-    ): Stream.Stream<V, UnavailableError, AccountCtx>;
+    /** @category Subscription & Loading */
+    subscribeEf<V extends Value, Depth>(
+        this: ClassOf<V>,
+        id: ID<V>,
+        depth: Depth & DepthsIn<V>,
+    ): Stream.Stream<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx>;
 }
 
-/** @category Schemas & CoValues - Abstract interfaces */
+/** @category Abstract interfaces */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface CoValue<Type extends string = string, Raw = any> {
-    /** @category Value identity */
+    /** @category Content */
     readonly id: ID<this>;
-    /** @category Value identity */
+    /** @category Type Helpers */
     _type: Type;
     /** @category Collaboration */
     _owner: Account | Group;
-    /** @category Subscription */
-    subscribe(listener: (update: this) => void): () => void;
-    /** @category Subscription */
-    subscribeEf(): Stream.Stream<this, UnavailableError, never>;
     /** @category Internals */
     _raw: Raw;
-    /** @category Internals */
-    readonly _loadedAs: Account & Me;
-    /** @category Stringifying & inspection */
+    /** @internal */
+    readonly _loadedAs: Account;
+    /** @category Stringifying & Inspection */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON(): any[] | object;
-    /** @category Stringifying & inspection */
+    /** @category Stringifying & Inspection */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     [inspect](): any;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isCoValue(value: any): value is CoValue {
     return value && value._type !== undefined;
 }
 
-/** @category Schemas & CoValues - Abstract interfaces */
-export type ID<T> = CojsonInternalTypes.RawCoID & {
-    readonly __type: T;
-};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isCoValueClass(value: any): value is CoValueClass {
+    return typeof value === "function" && value.fromRaw !== undefined;
+}
+
+/** @category CoValues */
+export type ID<T> = CojsonInternalTypes.RawCoID & IDMarker<T>;
+
+type IDMarker<out T> = { __type(_: never): T };
 
+/** @internal */
 export class CoValueBase implements CoValue {
     id!: ID<this>;
     _type!: string;
     _raw!: RawCoValue;
+    _instanceID!: string;
 
     get _owner(): Account | Group {
-        return this._raw.group instanceof RawAccount
-            ? Account.fromRaw(this._raw.group)
-            : Group.fromRaw(this._raw.group);
+        const owner =
+            this._raw.group instanceof RawAccount
+                ? Account.fromRaw(this._raw.group)
+                : Group.fromRaw(this._raw.group);
+
+        const subScope = subscriptionsScopes.get(this);
+        if (subScope) {
+            subScope.onRefAccessedOrSet(this.id, owner.id);
+            subscriptionsScopes.set(owner, subScope);
+        }
+
+        return owner;
     }
 
+    /** @private */
     get _loadedAs() {
         return Account.fromNode(this._raw.core.node);
     }
 
-    constructor(..._args: any) {}
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(..._args: any) {
+        Object.defineProperty(this, "_instanceID", {
+            value: `instance-${Math.random().toString(36).slice(2)}`,
+            enumerable: false,
+        });
+    }
 
-    static fromRaw<V extends CoValue>(
-        this: SubclassedConstructor<V>,
-        raw: RawCoValue
-    ): V {
-        return new this(undefined, { fromRaw: raw });
+    /** @category Internals */
+    static fromRaw<V extends CoValue>(this: ClassOf<V>, raw: RawCoValue): V {
+        return new this({ fromRaw: raw });
     }
 
-    static loadEf<V extends CoValue>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
-        id: ID<V>
-    ): Effect.Effect<V, UnavailableError, AccountCtx> {
-        return Effect.gen(this, function* (_) {
-            const account = yield* _(AccountCtx);
-            return yield* _(
-                new Ref(id as ID<V>, account, {
-                    ref: () => this as CoValueClass<V>,
-                }).loadEf()
-            );
-        });
+    /** @category Subscription & Loading */
+    static load<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
+        id: ID<V>,
+        as: Account,
+        depth: Depth & DepthsIn<V>,
+    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
+    /** @category Subscription & Loading */
+    static load<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
+        existing: V,
+        depth: Depth & DepthsIn<V>,
+    ): Promise<DeeplyLoaded<V, Depth> | undefined>;
+    static load<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
+
+        ...args:
+            | [ID<V>, Account, Depth & DepthsIn<V>]
+            | [V, Depth & DepthsIn<V>]
+    ): Promise<DeeplyLoaded<V, Depth> | undefined> {
+        const { id, as, depth } =
+            args.length === 3
+                ? { id: args[0], as: args[1], depth: args[2] }
+                : { id: args[0].id, as: args[0]._loadedAs, depth: args[1] };
+        return Effect.runPromise(
+            this.loadEf(id, depth).pipe(
+                Effect.mapError(() => undefined),
+                Effect.merge,
+                Effect.provideService(AccountCtx, as),
+            ),
+        );
     }
 
-    static load<V extends CoValue>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
+    /** @category Subscription & Loading */
+    static loadEf<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
         id: ID<V>,
-        options: {
-            as: Account & Me;
-            onProgress?: (progress: number) => void;
-        }
-    ): Promise<V | undefined> {
-        return new Ref(id as ID<V>, options.as, {
-            ref: () => this as CoValueClass<V>,
-        }).load(options?.onProgress && { onProgress: options.onProgress });
+        depth: Depth & DepthsIn<V>,
+    ): Effect.Effect<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
+        return this.subscribeEf(id, depth).pipe(
+            Stream.runHead,
+            Effect.andThen(
+                Effect.mapError((_noSuchElem) => "unavailable" as const),
+            ),
+        );
     }
 
-    static subscribe<V extends CoValue, Acc extends Account>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
+    /** @category Subscription & Loading */
+    static subscribe<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
         id: ID<V>,
-        options: { as: Acc & Me },
-        onUpdate: (value: V) => void
+        as: Account,
+        depth: Depth & DepthsIn<V>,
+        listener: (value: DeeplyLoaded<V, Depth>) => void,
+    ): () => void;
+    static subscribe<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
+        existing: V,
+        depth: Depth & DepthsIn<V>,
+        listener: (value: DeeplyLoaded<V, Depth>) => void,
+    ): () => void;
+    static subscribe<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
+        ...args:
+            | [
+                  ID<V>,
+                  Account,
+                  Depth & DepthsIn<V>,
+                  (value: DeeplyLoaded<V, Depth>) => void,
+              ]
+            | [V, Depth & DepthsIn<V>, (value: DeeplyLoaded<V, Depth>) => void]
     ): () => void {
+        const { id, as, depth, listener } =
+            args.length === 4
+                ? {
+                      id: args[0],
+                      as: args[1],
+                      depth: args[2],
+                      listener: args[3],
+                  }
+                : {
+                      id: args[0].id,
+                      as: args[0]._loadedAs,
+                      depth: args[1],
+                      listener: args[2],
+                  };
         void Effect.runPromise(
             Effect.provideService(
-                this.subscribeEf(id).pipe(
+                this.subscribeEf(id, depth).pipe(
                     Stream.run(
                         Sink.forEach((update) =>
-                            Effect.sync(() => onUpdate(update))
-                        )
-                    )
+                            Effect.sync(() => listener(update)),
+                        ),
+                    ),
                 ),
                 AccountCtx,
-                options.as as Account & Me
-            )
+                as,
+            ),
         );
 
         return function unsubscribe() {};
     }
 
-    static subscribeEf<V extends CoValue>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
-        id: ID<V>
-    ): Stream.Stream<V, UnavailableError, AccountCtx> {
-        return Stream.fromEffect(this.loadEf(id)).pipe(
-            Stream.flatMap((value) =>
+    /** @category Subscription & Loading */
+    static subscribeEf<V extends CoValue, Depth>(
+        this: ClassOf<V> & typeof CoValueBase,
+        id: ID<V>,
+        depth: Depth & DepthsIn<V>,
+    ): Stream.Stream<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
+        return AccountCtx.pipe(
+            Effect.andThen((account) =>
+                new Ref(id, account, {
+                    ref: this as CoValueClass<V>,
+                    optional: false,
+                }).loadEf(),
+            ),
+            Stream.fromEffect,
+            Stream.flatMap((value: V) =>
                 Stream.asyncScoped<V, UnavailableError>((emit) =>
                     Effect.gen(this, function* (_) {
                         const subscription = new SubscriptionScope(
                             value,
                             this,
-                            (update) => {
-                                void emit.single(update as V);
-                            }
+                            (update) => void emit.single(update as V),
                         );
 
                         yield* _(
                             Effect.addFinalizer(() =>
-                                Effect.sync(() => subscription.unsubscribeAll())
-                            )
+                                Effect.sync(() =>
+                                    subscription.unsubscribeAll(),
+                                ),
+                            ),
                         );
-                    })
-                )
-            )
-        );
-    }
-
-    subscribe(listener: (update: this) => void): () => void {
-        return (this.constructor as unknown as typeof CoValueBase).subscribe(
-            this.id as unknown as ID<CoValue>,
-            { as: this._loadedAs },
-            listener as unknown as (update: CoValue) => void
-        );
-    }
-
-    subscribeEf(): Stream.Stream<this, UnavailableError, never> {
-        return Stream.provideService(
-            (this.constructor as unknown as typeof CoValueBase).subscribeEf(
-                this.id as unknown as ID<CoValue>
+                    }),
+                ),
+            ),
+            Stream.filterMap((update: V) =>
+                Option.fromNullable(
+                    fulfillsDepth(depth, update)
+                        ? (update as DeeplyLoaded<V, Depth>)
+                        : undefined,
+                ),
             ),
-            AccountCtx,
-            this._loadedAs
-        ) as unknown as Stream.Stream<this, UnavailableError, never>;
+        );
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON(): object | any[] {
         return {
             id: this.id,
@@ -214,4 +304,14 @@ export class CoValueBase implements CoValue {
     [inspect]() {
         return this.toJSON();
     }
+
+    /** @category Type Helpers*/
+    as<C extends CoValueClass>(otherSchema: C): InstanceType<C> {
+        const cast = otherSchema.fromRaw(this._raw) as InstanceType<C>;
+        const subScope = subscriptionsScopes.get(this);
+        if (subScope) {
+            subscriptionsScopes.set(cast, subScope);
+        }
+        return cast;
+    }
 }

package/src/implementation/devtoolsFormatters.ts

@@ -0,0 +1,110 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ItemsSym } from "./symbols.js";
+
+(globalThis as any).devtoolsFormatters = [
+    {
+        header: (object: any) => {
+            if (object._type === "CoMap") {
+                return ["div", {}, ["span", {}, object.constructor.name]];
+            } else if (object._type === "CoList") {
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        {},
+                        object.constructor.name + "(" + object.length + ") ",
+                    ],
+                ];
+            } else if (object._type === "Account") {
+                return [
+                    "div",
+                    {},
+                    [
+                        "span",
+                        {},
+                        object.constructor.name +
+                            "(" +
+                            object._refs.profile.value?.name +
+                            (object.isMe ? " ME" : "") +
+                            ")",
+                    ],
+                ];
+            } else {
+                return null;
+            }
+        },
+        hasBody: function () {
+            return true;
+        },
+        body: function (object: any) {
+            if (object._type === "CoMap" || object._type === "Account") {
+                return [
+                    "div",
+                    { style: "margin-left: 15px" },
+                    ["div", "id: ", ["object", { object: object.id }]],
+                    ...Object.entries(object).map(([k, v]) => [
+                        "div",
+                        { style: "white-space: nowrap;" },
+                        [
+                            "span",
+                            { style: "font-weight: bold; opacity: 0.6" },
+                            k,
+                            ": ",
+                        ],
+                        ["object", { object: v }],
+                        ...(typeof object._schema[k] === "function"
+                            ? v === null
+                                ? [
+                                      [
+                                          "span",
+                                          { style: "opacity: 0.5" },
+                                          ` (pending ${object._schema[k].name} `,
+                                          [
+                                              "object",
+                                              { object: object._refs[k] },
+                                          ],
+                                          ")",
+                                      ],
+                                  ]
+                                : []
+                            : []),
+                    ]),
+                ];
+            } else if (object._type === "CoList") {
+                return [
+                    "div",
+                    { style: "margin-left: 15px" },
+                    ["div", "id: ", ["object", { object: object.id }]],
+                    ...(object as any[]).map((v, i) => [
+                        "div",
+                        { style: "white-space: nowrap;" },
+                        [
+                            "span",
+                            { style: "font-weight: bold; opacity: 0.6" },
+                            i,
+                            ": ",
+                        ],
+                        ["object", { object: v }],
+                        ...(typeof object._schema[ItemsSym] === "function"
+                            ? v === null
+                                ? [
+                                      [
+                                          "span",
+                                          { style: "opacity: 0.5" },
+                                          ` (pending ${object._schema[ItemsSym].name} `,
+                                          [
+                                              "object",
+                                              { object: object._refs[i] },
+                                          ],
+                                          ")",
+                                      ],
+                                  ]
+                                : []
+                            : []),
+                    ]),
+                ];
+            }
+        },
+    },
+];

package/src/implementation/inspect.ts

@@ -1,2 +1,2 @@
 export const inspect = Symbol.for("nodejs.util.inspect.custom");
-export type inspect = typeof inspect;
+export type inspect = typeof inspect;