jazz-tools 0.11.8 → 0.12.1

package/src/coValues/coMap.ts

@@ -12,13 +12,16 @@ import type {
   AnonymousJazzAgent,
   CoValue,
   CoValueClass,
-  DeeplyLoaded,
-  DepthsIn,
   ID,
   IfCo,
   RefEncoded,
   RefIfCoValue,
+  RefsToResolve,
+  RefsToResolveStrict,
+  Resolved,
   Schema,
+  SubscribeListenerOptions,
+  SubscribeRestArgs,
   co,
 } from "../internal.js";
 import {
@@ -32,6 +35,7 @@ import {
   loadCoValueWithoutMe,
   makeRefs,
   parseCoValueCreateOptions,
+  parseSubscribeRestArgs,
   subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
   subscriptionsScopes,
@@ -433,24 +437,15 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @category Subscription & Loading
    */
-  static load<C extends CoMap, Depth>(
-    this: CoValueClass<C>,
-    id: ID<C>,
-    depth: Depth & DepthsIn<C>,
-  ): Promise<DeeplyLoaded<C, Depth> | undefined>;
-  static load<C extends CoMap, Depth>(
-    this: CoValueClass<C>,
-    id: ID<C>,
-    as: Account,
-    depth: Depth & DepthsIn<C>,
-  ): Promise<DeeplyLoaded<C, Depth> | undefined>;
-  static load<C extends CoMap, Depth>(
-    this: CoValueClass<C>,
-    id: ID<C>,
-    asOrDepth: Account | (Depth & DepthsIn<C>),
-    depth?: Depth & DepthsIn<C>,
-  ): Promise<DeeplyLoaded<C, Depth> | undefined> {
-    return loadCoValueWithoutMe(this, id, asOrDepth, depth);
+  static load<M extends CoMap, const R extends RefsToResolve<M> = true>(
+    this: CoValueClass<M>,
+    id: ID<M>,
+    options?: {
+      resolve?: RefsToResolveStrict<M, R>;
+      loadAs?: Account | AnonymousJazzAgent;
+    },
+  ): Promise<Resolved<M, R> | null> {
+    return loadCoValueWithoutMe(this, id, options);
   }
 
   /**
@@ -480,35 +475,24 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @category Subscription & Loading
    */
-  static subscribe<C extends CoMap, Depth>(
-    this: CoValueClass<C>,
-    id: ID<C>,
-    depth: Depth & DepthsIn<C>,
-    listener: (value: DeeplyLoaded<C, Depth>) => void,
+  static subscribe<M extends CoMap, const R extends RefsToResolve<M> = true>(
+    this: CoValueClass<M>,
+    id: ID<M>,
+    listener: (value: Resolved<M, R>, unsubscribe: () => void) => void,
   ): () => void;
-  static subscribe<C extends CoMap, Depth>(
-    this: CoValueClass<C>,
-    id: ID<C>,
-    as: Account,
-    depth: Depth & DepthsIn<C>,
-    listener: (value: DeeplyLoaded<C, Depth>) => void,
+  static subscribe<M extends CoMap, const R extends RefsToResolve<M> = true>(
+    this: CoValueClass<M>,
+    id: ID<M>,
+    options: SubscribeListenerOptions<M, R>,
+    listener: (value: Resolved<M, R>, unsubscribe: () => void) => void,
   ): () => void;
-  static subscribe<C extends CoMap, Depth>(
-    this: CoValueClass<C>,
-    id: ID<C>,
-    asOrDepth: Account | (Depth & DepthsIn<C>),
-    depthOrListener:
-      | (Depth & DepthsIn<C>)
-      | ((value: DeeplyLoaded<C, Depth>) => void),
-    listener?: (value: DeeplyLoaded<C, Depth>) => void,
+  static subscribe<M extends CoMap, const R extends RefsToResolve<M>>(
+    this: CoValueClass<M>,
+    id: ID<M>,
+    ...args: SubscribeRestArgs<M, R>
   ): () => void {
-    return subscribeToCoValueWithoutMe<C, Depth>(
-      this,
-      id,
-      asOrDepth,
-      depthOrListener,
-      listener,
-    );
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe<M, R>(this, id, options, listener);
   }
 
   static findUnique<M extends CoMap>(
@@ -540,11 +524,11 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @category Subscription & Loading
    */
-  ensureLoaded<M extends CoMap, Depth>(
+  ensureLoaded<M extends CoMap, const R extends RefsToResolve<M>>(
     this: M,
-    depth: Depth & DepthsIn<M>,
-  ): Promise<DeeplyLoaded<M, Depth>> {
-    return ensureCoValueLoaded(this, depth);
+    options: { resolve: RefsToResolveStrict<M, R> },
+  ): Promise<Resolved<M, R>> {
+    return ensureCoValueLoaded(this, options);
   }
 
   /**
@@ -556,12 +540,21 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * @category Subscription & Loading
    **/
-  subscribe<M extends CoMap, Depth>(
+  subscribe<M extends CoMap, const R extends RefsToResolve<M> = true>(
+    this: M,
+    listener: (value: Resolved<M, R>, unsubscribe: () => void) => void,
+  ): () => void;
+  subscribe<M extends CoMap, const R extends RefsToResolve<M> = true>(
+    this: M,
+    options: { resolve?: RefsToResolveStrict<M, R> },
+    listener: (value: Resolved<M, R>, unsubscribe: () => void) => void,
+  ): () => void;
+  subscribe<M extends CoMap, const R extends RefsToResolve<M>>(
     this: M,
-    depth: Depth & DepthsIn<M>,
-    listener: (value: DeeplyLoaded<M, Depth>) => void,
+    ...args: SubscribeRestArgs<M, R>
   ): () => void {
-    return subscribeToExistingCoValue(this, depth, listener);
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToExistingCoValue<M, R>(this, options, listener);
   }
 
   applyDiff<N extends Partial<CoMapInit<this>>>(newValues: N) {

package/src/coValues/coPlainText.ts

@@ -4,13 +4,20 @@ import {
   type RawCoPlainText,
   stringifyOpID,
 } from "cojson";
-import { activeAccountContext } from "../implementation/activeAccountContext.js";
-import type { CoValue, CoValueClass, ID } from "../internal.js";
+import type {
+  AnonymousJazzAgent,
+  CoValue,
+  CoValueClass,
+  ID,
+  Resolved,
+  SubscribeListenerOptions,
+  SubscribeRestArgs,
+} from "../internal.js";
 import {
   inspect,
-  isAccountInstance,
-  loadCoValue,
-  subscribeToCoValue,
+  loadCoValueWithoutMe,
+  parseSubscribeRestArgs,
+  subscribeToCoValueWithoutMe,
   subscribeToExistingCoValue,
 } from "../internal.js";
 import { Account } from "./account.js";
@@ -122,9 +129,9 @@ export class CoPlainText extends String implements CoValue {
   static load<T extends CoPlainText>(
     this: CoValueClass<T>,
     id: ID<T>,
-    as?: Account,
-  ): Promise<T | undefined> {
-    return loadCoValue(this, id, as ?? activeAccountContext.get(), []);
+    options?: { loadAs?: Account | AnonymousJazzAgent },
+  ): Promise<T | null> {
+    return loadCoValueWithoutMe(this, id, options);
   }
 
   //   /**
@@ -157,47 +164,23 @@ export class CoPlainText extends String implements CoValue {
   static subscribe<T extends CoPlainText>(
     this: CoValueClass<T>,
     id: ID<T>,
-    listener: (value: T) => void,
+    listener: (value: Resolved<T, true>, unsubscribe: () => void) => void,
   ): () => void;
   static subscribe<T extends CoPlainText>(
     this: CoValueClass<T>,
     id: ID<T>,
-    as: Account,
-    listener: (value: T) => void,
+    options: Omit<SubscribeListenerOptions<T, true>, "resolve">,
+    listener: (value: Resolved<T, true>, unsubscribe: () => void) => void,
   ): () => void;
   static subscribe<T extends CoPlainText>(
     this: CoValueClass<T>,
     id: ID<T>,
-    asOrListener: Account | ((value: T) => void),
-    listener?: (value: T) => void,
+    ...args: SubscribeRestArgs<T, true>
   ): () => void {
-    if (isAccountInstance(asOrListener)) {
-      return subscribeToCoValue(this, id, asOrListener, [], listener!);
-    }
-
-    return subscribeToCoValue(
-      this,
-      id,
-      activeAccountContext.get(),
-      [],
-      listener!,
-    );
+    const { options, listener } = parseSubscribeRestArgs(args);
+    return subscribeToCoValueWithoutMe<T, true>(this, id, options, listener);
   }
 
-  //   /**
-  //    * Effectful version of `CoMap.subscribe()` that returns a stream of updates.
-  //    *
-  //    * Needs to be run inside an `AccountCtx` context.
-  //    *
-  //    * @category Subscription & Loading
-  //    */
-  //   static subscribeEf<T extends CoPlainText>(
-  //     this: CoValueClass<T>,
-  //     id: ID<T>,
-  //   ): Stream.Stream<T, UnavailableError, AccountCtx> {
-  //     return subscribeToCoValueEf(this, id, []);
-  //   }
-
   /**
    * Given an already loaded `CoPlainText`, subscribe to updates to the `CoPlainText` and ensure that the specified fields are loaded to the specified depth.
    *
@@ -209,8 +192,8 @@ export class CoPlainText extends String implements CoValue {
    **/
   subscribe<T extends CoPlainText>(
     this: T,
-    listener: (value: T) => void,
+    listener: (value: Resolved<T, true>, unsubscribe: () => void) => void,
   ): () => void {
-    return subscribeToExistingCoValue(this, [], listener);
+    return subscribeToExistingCoValue(this, {}, listener);
   }
 }