jazz-tools 0.8.14 → 0.8.16

package/src/coValues/interfaces.ts

@@ -2,60 +2,60 @@ import type { CojsonInternalTypes, RawCoValue } from "cojson";
 import { RawAccount } from "cojson";
 import type { DeeplyLoaded, DepthsIn } from "../internal.js";
 import {
-    Account,
-    Group,
-    SubscriptionScope,
-    Ref,
-    inspect,
-    subscriptionsScopes,
-    AnonymousJazzAgent,
+  Account,
+  AnonymousJazzAgent,
+  Group,
+  Ref,
+  SubscriptionScope,
+  inspect,
+  subscriptionsScopes,
 } from "../internal.js";
-import { fulfillsDepth } from "./deepLoading.js";
 import { coValuesCache } from "../lib/cache.js";
+import { fulfillsDepth } from "./deepLoading.js";
 
 /** @category Abstract interfaces */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface CoValueClass<Value extends CoValue = CoValue> {
-    /** @ignore */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new (...args: any[]): Value;
+  /** @ignore */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new (...args: any[]): Value;
 }
 
 export interface CoValueFromRaw<V extends CoValue> {
-    fromRaw(raw: V["_raw"]): V;
+  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 Type Helpers */
-    _type: string;
-    /** @category Collaboration */
-    _owner: Account | Group;
-    /** @category Internals */
-    _raw: RawCoValue;
-    /** @internal */
-    readonly _loadedAs: Account | AnonymousJazzAgent;
-    /** @category Stringifying & Inspection */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    toJSON(key?: string, seenAbove?: ID<CoValue>[]): any[] | object | string;
-    /** @category Stringifying & Inspection */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [inspect](): any;
+  /** @category Content */
+  readonly id: ID<this>;
+  /** @category Type Helpers */
+  _type: string;
+  /** @category Collaboration */
+  _owner: Account | Group;
+  /** @category Internals */
+  _raw: RawCoValue;
+  /** @internal */
+  readonly _loadedAs: Account | AnonymousJazzAgent;
+  /** @category Stringifying & Inspection */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON(key?: string, seenAbove?: ID<CoValue>[]): any[] | object | string;
+  /** @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;
+  return value && value._type !== undefined;
 }
 
 export function isCoValueClass<V extends CoValue>(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    value: any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  value: any,
 ): value is CoValueClass<V> & CoValueFromRaw<V> {
-    return typeof value === "function" && value.fromRaw !== undefined;
+  return typeof value === "function" && value.fromRaw !== undefined;
 }
 
 /** @category CoValues */
@@ -65,202 +65,200 @@ type IDMarker<out T> = { __type(_: never): T };
 
 /** @internal */
 export class CoValueBase implements CoValue {
-    declare id: ID<this>;
-    declare _type: string;
-    declare _raw: RawCoValue;
-    /** @category Internals */
-    declare _instanceID: string;
-
-    get _owner(): Account | 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;
+  declare id: ID<this>;
+  declare _type: string;
+  declare _raw: RawCoValue;
+  /** @category Internals */
+  declare _instanceID: string;
+
+  get _owner(): Account | 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);
     }
 
-    /** @private */
-    get _loadedAs() {
-        const rawAccount = this._raw.core.node.account;
+    return owner;
+  }
 
-        if (rawAccount instanceof RawAccount) {
-            return coValuesCache.get(rawAccount, () => Account.fromRaw(rawAccount)) ;
-        }
+  /** @private */
+  get _loadedAs() {
+    const rawAccount = this._raw.core.node.account;
 
-        return new AnonymousJazzAgent(this._raw.core.node);
+    if (rawAccount instanceof RawAccount) {
+      return coValuesCache.get(rawAccount, () => Account.fromRaw(rawAccount));
     }
 
-    // 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: CoValueClass<V>,
-        raw: RawCoValue,
-    ): V {
-        return new this({ fromRaw: raw });
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    toJSON(): object | any[] | string {
-        return {
-            id: this.id,
-            type: this._type,
-            error: "unknown CoValue class",
-        };
-    }
-
-    [inspect]() {
-        return this.toJSON();
-    }
+    return new AnonymousJazzAgent(this._raw.core.node);
+  }
 
-    /** @category Type Helpers */
-    castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
-        cl: Cl,
-    ): InstanceType<Cl> {
-        const casted = cl.fromRaw(this._raw) as InstanceType<Cl>;
-        const subscriptionScope = subscriptionsScopes.get(this);
-        if (subscriptionScope) {
-            subscriptionsScopes.set(casted, subscriptionScope);
-        }
-        return casted;
+  // 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: CoValueClass<V>, raw: RawCoValue): V {
+    return new this({ fromRaw: raw });
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  toJSON(): object | any[] | string {
+    return {
+      id: this.id,
+      type: this._type,
+      error: "unknown CoValue class",
+    };
+  }
+
+  [inspect]() {
+    return this.toJSON();
+  }
+
+  /** @category Type Helpers */
+  castAs<Cl extends CoValueClass & CoValueFromRaw<CoValue>>(
+    cl: Cl,
+  ): InstanceType<Cl> {
+    const casted = cl.fromRaw(this._raw) as InstanceType<Cl>;
+    const subscriptionScope = subscriptionsScopes.get(this);
+    if (subscriptionScope) {
+      subscriptionsScopes.set(casted, subscriptionScope);
     }
+    return casted;
+  }
 }
 
 export function loadCoValue<V extends CoValue, Depth>(
-    cls: CoValueClass<V>,
-    id: ID<V>,
-    as: Account | AnonymousJazzAgent,
-    depth: Depth & DepthsIn<V>,
+  cls: CoValueClass<V>,
+  id: ID<V>,
+  as: Account | AnonymousJazzAgent,
+  depth: Depth & DepthsIn<V>,
 ): Promise<DeeplyLoaded<V, Depth> | undefined> {
-    return new Promise((resolve) => {
-        const unsubscribe = subscribeToCoValue(
-            cls,
-            id,
-            as,
-            depth,
-            (value) => {
-                resolve(value);
-                unsubscribe();
-            },
-            () => {
-                resolve(undefined);
-                unsubscribe();
-            },
-        );
-    });
+  return new Promise((resolve) => {
+    const unsubscribe = subscribeToCoValue(
+      cls,
+      id,
+      as,
+      depth,
+      (value) => {
+        resolve(value);
+        unsubscribe();
+      },
+      () => {
+        resolve(undefined);
+        unsubscribe();
+      },
+    );
+  });
 }
 
 export function ensureCoValueLoaded<V extends CoValue, Depth>(
-    existing: V,
-    depth: Depth & DepthsIn<V>,
+  existing: V,
+  depth: Depth & DepthsIn<V>,
 ): Promise<DeeplyLoaded<V, Depth> | undefined> {
-    return loadCoValue(
-        existing.constructor as CoValueClass<V>,
-        existing.id,
-        existing._loadedAs,
-        depth,
-    );
+  return loadCoValue(
+    existing.constructor as CoValueClass<V>,
+    existing.id,
+    existing._loadedAs,
+    depth,
+  );
 }
 
 export function subscribeToCoValue<V extends CoValue, Depth>(
+  cls: CoValueClass<V>,
+  id: ID<V>,
+  as: Account | AnonymousJazzAgent,
+  depth: Depth & DepthsIn<V>,
+  listener: (value: DeeplyLoaded<V, Depth>) => void,
+  onUnavailable?: () => void,
+): () => void {
+  const ref = new Ref(id, as, { ref: cls, optional: false });
+
+  let unsubscribed = false;
+  let unsubscribe: (() => void) | undefined;
+
+  ref
+    .load()
+    .then((value) => {
+      if (!value) {
+        onUnavailable && onUnavailable();
+        return;
+      }
+      if (unsubscribed) return;
+      const subscription = new SubscriptionScope(
+        value,
+        cls as CoValueClass<V> & CoValueFromRaw<V>,
+        (update) => {
+          if (fulfillsDepth(depth, update)) {
+            listener(update as DeeplyLoaded<V, Depth>);
+          }
+        },
+      );
+
+      unsubscribe = () => subscription.unsubscribeAll();
+    })
+    .catch((e) => {
+      console.error("Failed to load / subscribe to CoValue", e);
+    });
+
+  return function unsubscribeAtAnyPoint() {
+    unsubscribed = true;
+    unsubscribe && unsubscribe();
+  };
+}
+
+export function createCoValueObservable<V extends CoValue, Depth>() {
+  let currentValue: DeeplyLoaded<V, Depth> | undefined = undefined;
+
+  function subscribe(
     cls: CoValueClass<V>,
     id: ID<V>,
     as: Account | AnonymousJazzAgent,
     depth: Depth & DepthsIn<V>,
-    listener: (value: DeeplyLoaded<V, Depth>) => void,
+    listener: () => void,
     onUnavailable?: () => void,
-): () => void {
-    const ref = new Ref(id, as, { ref: cls, optional: false });
-
-    let unsubscribed = false;
-    let unsubscribe: (() => void) | undefined;
-
-    ref.load()
-        .then((value) => {
-            if (!value) {
-                onUnavailable && onUnavailable();
-                return;
-            }
-            if (unsubscribed) return;
-            const subscription = new SubscriptionScope(
-                value,
-                cls as CoValueClass<V> & CoValueFromRaw<V>,
-                (update) => {
-                    if (fulfillsDepth(depth, update)) {
-                        listener(update as DeeplyLoaded<V, Depth>);
-                    }
-                },
-            );
-
-            unsubscribe = () => subscription.unsubscribeAll();
-        })
-        .catch((e) => {
-            console.error("Failed to load / subscribe to CoValue", e);
-        });
-
-    return function unsubscribeAtAnyPoint() {
-        unsubscribed = true;
-        unsubscribe && unsubscribe();
-    };
-}
+  ) {
+    const unsubscribe = subscribeToCoValue(
+      cls,
+      id,
+      as,
+      depth,
+      (value) => {
+        currentValue = value;
+        listener();
+      },
+      onUnavailable,
+    );
 
-export function createCoValueObservable<V extends CoValue, Depth>() {
-    let currentValue: DeeplyLoaded<V, Depth> | undefined = undefined;
-
-    function subscribe(
-        cls: CoValueClass<V>,
-        id: ID<V>,
-        as: Account | AnonymousJazzAgent,
-        depth: Depth & DepthsIn<V>,
-        listener: () => void,
-        onUnavailable?: () => void,
-    ) {
-        const unsubscribe = subscribeToCoValue(
-            cls,
-            id,
-            as,
-            depth,
-            (value) => {
-                currentValue = value;
-                listener();
-            },
-            onUnavailable,
-        );
-
-        return unsubscribe
-    }
+    return unsubscribe;
+  }
 
-    const observable = {
-        getCurrentValue: () => currentValue,
-        subscribe,
-    };
+  const observable = {
+    getCurrentValue: () => currentValue,
+    subscribe,
+  };
 
-    return observable;
+  return observable;
 }
 
 export function subscribeToExistingCoValue<V extends CoValue, Depth>(
-    existing: V,
-    depth: Depth & DepthsIn<V>,
-    listener: (value: DeeplyLoaded<V, Depth>) => void,
+  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,
-    );
+  return subscribeToCoValue(
+    existing.constructor as CoValueClass<V>,
+    existing.id,
+    existing._loadedAs,
+    depth,
+    listener,
+  );
 }

package/src/exports.ts

@@ -1,35 +1,48 @@
 export type {
-    InviteSecret,
-    Peer,
-    SessionID,
-    AgentID,
-    SyncMessage,
-    CryptoProvider,
-    CoValueUniqueness,
+  AgentID,
+  CoValueUniqueness,
+  CryptoProvider,
+  InviteSecret,
+  Peer,
+  SessionID,
+  SyncMessage,
 } from "cojson";
 
-export type { ID, CoValue } from "./internal.js";
+export type { CoValue, ID } from "./internal.js";
 
 export { Encoders, co } from "./internal.js";
 
-export { CoMap, type CoMapInit } from "./internal.js";
-export { CoList } from "./internal.js";
-export { CoStream, BinaryCoStream } from "./internal.js";
-export { Group, Profile } from "./internal.js";
-export { Account, isControlledAccount, type AccountClass } from "./internal.js";
-export { ImageDefinition } from "./internal.js";
-export { CoValueBase, type CoValueClass } from "./internal.js";
-export type { DepthsIn, DeeplyLoaded } from "./internal.js";
+export {
+  Account,
+  BinaryCoStream,
+  CoList,
+  CoMap,
+  CoStream,
+  CoValueBase,
+  Group,
+  ImageDefinition,
+  Profile,
+  isControlledAccount,
+  type AccountClass,
+  type CoMapInit,
+  type CoValueClass,
+} from "./internal.js";
+export type { DeeplyLoaded, DepthsIn } from "./internal.js";
 
-export { loadCoValue, subscribeToCoValue, createCoValueObservable } from "./internal.js";
+export {
+  createCoValueObservable,
+  loadCoValue,
+  subscribeToCoValue,
+} from "./internal.js";
 
 export {
-    type AuthMethod,
-    type AuthResult,
-    createJazzContext,
-    fixedCredentialsAuth,
-    ephemeralCredentialsAuth,
-    AnonymousJazzAgent,
-    createAnonymousJazzContext,
-    randomSessionProvider,
+  AnonymousJazzAgent,
+  createAnonymousJazzContext,
+  createJazzContext,
+  ephemeralCredentialsAuth,
+  fixedCredentialsAuth,
+  randomSessionProvider,
+  type AuthMethod,
+  type AuthResult,
+  type Credentials,
 } from "./internal.js";