jazz-tools 0.7.0-alpha.9 → 0.7.3

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,209 +9,238 @@ import {
     SubscriptionScope,
     Ref,
     inspect,
+    subscriptionsScopes,
 } from "../internal.js";
+import { fulfillsDepth } from "./deepLoading.js";
 
-export type SubclassedConstructor<T> = {
-    new (...args: any[]): T;
-};
-
-export interface CoValueClass<Value extends CoValue = CoValue, Init = any> {
-    /** @category Construction and loading */
-    new (init: Init, options: { owner: Account | Group }): Value;
-
+/** @category Abstract interfaces */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface CoValueClass<Value extends CoValue = CoValue> {
     /** @ignore */
-    fromRaw(raw: Value["_raw"]): Value;
-
-    /** @category Construction and loading */
-    load<V extends Value>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>,
-        options: {
-            as: Account & Me;
-            onProgress?: (progress: number) => void;
-        }
-    ): Promise<V | undefined>;
-
-    /** @category Construction and loading */
-    loadEf<V extends Value>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>
-    ): Effect.Effect<V, UnavailableError, AccountCtx>;
-
-    /** @category Subscription */
-    subscribe<V extends Value, Acc extends Account>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>,
-        options: { as: Acc & Me },
-        onUpdate: (value: V) => void
-    ): () => void;
-
-    /** @category Subscription */
-    subscribeEf<V extends Value>(
-        this: SubclassedConstructor<V>,
-        id: ID<V>
-    ): Stream.Stream<V, UnavailableError, AccountCtx>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    new (...args: any[]): Value;
 }
 
-/** @category Schemas & CoValues - Abstract interfaces */
-export interface CoValue<Type extends string = string, Raw = any> {
-    /** @category Value identity */
+export interface CoValueFromRaw<V extends CoValue> {
+    fromRaw(raw: V["_raw"]): V;
+}
+
+/** @category Abstract interfaces */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface CoValue {
+    /** @category Content */
     readonly id: ID<this>;
-    /** @category Value identity */
-    _type: Type;
+    /** @category Type Helpers */
+    _type: string;
     /** @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 */
+    _raw: RawCoValue;
+    /** @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;
-};
+export function isCoValueClass<V extends CoValue>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    value: any,
+): value is CoValueClass<V> & CoValueFromRaw<V> {
+    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,
+        });
+    }
 
+    /** @category Internals */
     static fromRaw<V extends CoValue>(
-        this: SubclassedConstructor<V>,
-        raw: RawCoValue
+        this: CoValueClass<V>,
+        raw: RawCoValue,
     ): V {
-        return new this(undefined, { fromRaw: raw });
+        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()
-            );
-        });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    toJSON(): object | any[] {
+        return {
+            id: this.id,
+            type: this._type,
+            error: "unknown CoValue class",
+        };
     }
 
-    static load<V extends CoValue>(
-        this: SubclassedConstructor<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 });
+    [inspect]() {
+        return this.toJSON();
     }
 
-    static subscribe<V extends CoValue, Acc extends Account>(
-        this: SubclassedConstructor<V> & typeof CoValueBase,
-        id: ID<V>,
-        options: { as: Acc & Me },
-        onUpdate: (value: V) => void
-    ): () => void {
-        void Effect.runPromise(
-            Effect.provideService(
-                this.subscribeEf(id).pipe(
-                    Stream.run(
-                        Sink.forEach((update) =>
-                            Effect.sync(() => onUpdate(update))
-                        )
-                    )
-                ),
-                AccountCtx,
-                options.as as Account & Me
-            )
-        );
-
-        return function unsubscribe() {};
+    /** @category Type Helpers */
+    castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
+        cl: Cl,
+    ): InstanceType<Cl> {
+        return cl.fromRaw(this._raw) as InstanceType<Cl>;
     }
+}
 
-    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) =>
-                Stream.asyncScoped<V, UnavailableError>((emit) =>
-                    Effect.gen(this, function* (_) {
-                        const subscription = new SubscriptionScope(
-                            value,
-                            this,
-                            (update) => {
-                                void emit.single(update as V);
-                            }
-                        );
-
-                        yield* _(
-                            Effect.addFinalizer(() =>
-                                Effect.sync(() => subscription.unsubscribeAll())
-                            )
-                        );
-                    })
-                )
-            )
-        );
-    }
+export function loadCoValue<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    as: Account,
+    depth: Depth & DepthsIn<V>,
+): Promise<DeeplyLoaded<V, Depth> | undefined> {
+    return Effect.runPromise(
+        loadCoValueEf(cls, id, depth).pipe(
+            Effect.mapError(() => undefined),
+            Effect.merge,
+            Effect.provideService(AccountCtx, as),
+        ),
+    );
+}
 
-    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
-        );
-    }
+export function ensureCoValueLoaded<V extends CoValue, Depth>(
+    existing: V,
+    depth: Depth & DepthsIn<V>,
+): Promise<DeeplyLoaded<V, Depth> | undefined> {
+    return loadCoValue(
+        existing.constructor as CoValueClass<V>,
+        existing.id,
+        existing._loadedAs,
+        depth,
+    );
+}
 
-    subscribeEf(): Stream.Stream<this, UnavailableError, never> {
-        return Stream.provideService(
-            (this.constructor as unknown as typeof CoValueBase).subscribeEf(
-                this.id as unknown as ID<CoValue>
+export function loadCoValueEf<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    depth: Depth & DepthsIn<V>,
+): Effect.Effect<DeeplyLoaded<V, Depth>, UnavailableError, AccountCtx> {
+    return subscribeToCoValueEf(cls, id, depth).pipe(
+        Stream.runHead,
+        Effect.andThen(
+            Effect.mapError((_noSuchElem) => "unavailable" as const),
+        ),
+    );
+}
+
+export function subscribeToCoValue<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    id: ID<V>,
+    as: Account,
+    depth: Depth & DepthsIn<V>,
+    listener: (value: DeeplyLoaded<V, Depth>) => void,
+): () => void {
+    void Effect.runPromise(
+        Effect.provideService(
+            subscribeToCoValueEf(cls, id, depth).pipe(
+                Stream.run(
+                    Sink.forEach((update) =>
+                        Effect.sync(() => listener(update)),
+                    ),
+                ),
             ),
             AccountCtx,
-            this._loadedAs
-        ) as unknown as Stream.Stream<this, UnavailableError, never>;
-    }
+            as,
+        ),
+    );
 
-    toJSON(): object | any[] {
-        return {
-            id: this.id,
-            type: this._type,
-            error: "unknown CoValue class",
-        };
-    }
+    return function unsubscribe() {};
+}
 
-    [inspect]() {
-        return this.toJSON();
-    }
+export function subscribeToExistingCoValue<V extends CoValue, Depth>(
+    existing: V,
+    depth: Depth & DepthsIn<V>,
+    listener: (value: DeeplyLoaded<V, Depth>) => void,
+): () => void {
+    return subscribeToCoValue(
+        existing.constructor as CoValueClass<V>,
+        existing.id,
+        existing._loadedAs,
+        depth,
+        listener,
+    );
+}
+
+export function subscribeToCoValueEf<V extends CoValue, Depth>(
+    cls: CoValueClass<V>,
+    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: cls,
+                optional: false,
+            }).loadEf(),
+        ),
+        Stream.fromEffect,
+        Stream.flatMap((value: V) =>
+            Stream.asyncScoped<V, UnavailableError>((emit) =>
+                Effect.gen(function* (_) {
+                    const subscription = new SubscriptionScope(
+                        value,
+                        cls as CoValueClass<V> & CoValueFromRaw<V>,
+                        (update) => void emit.single(update as V),
+                    );
+
+                    yield* _(
+                        Effect.addFinalizer(() =>
+                            Effect.sync(() => subscription.unsubscribeAll()),
+                        ),
+                    );
+                }),
+            ),
+        ),
+        Stream.filterMap((update: V) =>
+            Option.fromNullable(
+                fulfillsDepth(depth, update)
+                    ? (update as DeeplyLoaded<V, Depth>)
+                    : undefined,
+            ),
+        ),
+    );
 }

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;