jazz-tools 0.8.14 → 0.8.16

package/src/implementation/refs.ts

@@ -1,171 +1,159 @@
 import type { CoID, RawCoValue } from "cojson";
 import type {
-    Account,
-    AnonymousJazzAgent,
-    CoValue,
-    ID,
-    RefEncoded,
-    UnCo,
+  Account,
+  AnonymousJazzAgent,
+  CoValue,
+  ID,
+  RefEncoded,
+  UnCo,
 } from "../internal.js";
 import {
-    instantiateRefEncoded,
-    isRefEncoded,
-    subscriptionsScopes,
+  instantiateRefEncoded,
+  isRefEncoded,
+  subscriptionsScopes,
 } from "../internal.js";
 import { coValuesCache } from "../lib/cache.js";
 
 const TRACE_ACCESSES = false;
 
 export class Ref<out V extends CoValue> {
-    constructor(
-        readonly id: ID<V>,
-        readonly controlledAccount: Account | AnonymousJazzAgent,
-        readonly schema: RefEncoded<V>,
-    ) {
-        if (!isRefEncoded(schema)) {
-            throw new Error("Ref must be constructed with a ref schema");
-        }
+  constructor(
+    readonly id: ID<V>,
+    readonly controlledAccount: Account | AnonymousJazzAgent,
+    readonly schema: RefEncoded<V>,
+  ) {
+    if (!isRefEncoded(schema)) {
+      throw new Error("Ref must be constructed with a ref schema");
     }
+  }
 
-    get value() {
-        const node =
-            "node" in this.controlledAccount
-                ? this.controlledAccount.node
-                : this.controlledAccount._raw.core.node;
-        const raw = node.getLoaded(this.id as unknown as CoID<RawCoValue>);
-        if (raw) {
-            return coValuesCache.get(raw, () =>
-                instantiateRefEncoded(this.schema, raw),
-            );
-        } else {
-            return null;
-        }
+  get value() {
+    const node =
+      "node" in this.controlledAccount
+        ? this.controlledAccount.node
+        : this.controlledAccount._raw.core.node;
+    const raw = node.getLoaded(this.id as unknown as CoID<RawCoValue>);
+    if (raw) {
+      return coValuesCache.get(raw, () =>
+        instantiateRefEncoded(this.schema, raw),
+      );
+    } else {
+      return null;
     }
+  }
 
-    private async loadHelper(): Promise<V | "unavailable"> {
-        const node =
-            "node" in this.controlledAccount
-                ? this.controlledAccount.node
-                : this.controlledAccount._raw.core.node;
-        const raw = await node.load(
-            this.id as unknown as CoID<RawCoValue>,
-        );
-        if (raw === "unavailable") {
-            return "unavailable";
-        } else {
-            return new Ref(this.id, this.controlledAccount, this.schema).value!;
-        }
+  private async loadHelper(): Promise<V | "unavailable"> {
+    const node =
+      "node" in this.controlledAccount
+        ? this.controlledAccount.node
+        : this.controlledAccount._raw.core.node;
+    const raw = await node.load(this.id as unknown as CoID<RawCoValue>);
+    if (raw === "unavailable") {
+      return "unavailable";
+    } else {
+      return new Ref(this.id, this.controlledAccount, this.schema).value!;
     }
+  }
 
-    async load(): Promise<V | undefined> {
-        const result = await this.loadHelper();
-        if (result === "unavailable") {
-            return undefined;
-        } else {
-            return result;
-        }
+  async load(): Promise<V | undefined> {
+    const result = await this.loadHelper();
+    if (result === "unavailable") {
+      return undefined;
+    } else {
+      return result;
     }
+  }
 
-    accessFrom(
-        fromScopeValue: CoValue,
-        key: string | number | symbol,
-    ): V | null {
-        const subScope = subscriptionsScopes.get(fromScopeValue);
+  accessFrom(fromScopeValue: CoValue, key: string | number | symbol): V | null {
+    const subScope = subscriptionsScopes.get(fromScopeValue);
 
-        subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
-        TRACE_ACCESSES &&
-            console.log(
-                subScope?.scopeID,
-                "accessing",
-                fromScopeValue,
-                key,
-                this.id,
-            );
+    subScope?.onRefAccessedOrSet(fromScopeValue.id, this.id);
+    TRACE_ACCESSES &&
+      console.log(subScope?.scopeID, "accessing", fromScopeValue, key, this.id);
 
-        if (this.value && subScope) {
-            subscriptionsScopes.set(this.value, subScope);
-        }
+    if (this.value && subScope) {
+      subscriptionsScopes.set(this.value, subScope);
+    }
 
-        if (subScope) {
-            const cached = subScope.cachedValues[this.id];
-            if (cached) {
-                TRACE_ACCESSES && console.log("cached", cached);
-                return cached as V;
-            } else if (this.value !== null) {
-                const freshValueInstance = instantiateRefEncoded(
-                    this.schema,
-                    this.value?._raw,
-                );
-                TRACE_ACCESSES &&
-                    console.log("freshValueInstance", freshValueInstance);
-                subScope.cachedValues[this.id] = freshValueInstance;
-                subscriptionsScopes.set(freshValueInstance, subScope);
-                return freshValueInstance as V;
-            } else {
-                return null;
-            }
-        } else {
-            return this.value;
-        }
+    if (subScope) {
+      const cached = subScope.cachedValues[this.id];
+      if (cached) {
+        TRACE_ACCESSES && console.log("cached", cached);
+        return cached as V;
+      } else if (this.value !== null) {
+        const freshValueInstance = instantiateRefEncoded(
+          this.schema,
+          this.value?._raw,
+        );
+        TRACE_ACCESSES && console.log("freshValueInstance", freshValueInstance);
+        subScope.cachedValues[this.id] = freshValueInstance;
+        subscriptionsScopes.set(freshValueInstance, subScope);
+        return freshValueInstance as V;
+      } else {
+        return null;
+      }
+    } else {
+      return this.value;
     }
+  }
 }
 
 export function makeRefs<Keys extends string | number>(
-    getIdForKey: (key: Keys) => ID<CoValue> | undefined,
-    getKeysWithIds: () => Keys[],
-    controlledAccount: Account | AnonymousJazzAgent,
-    refSchemaForKey: (key: Keys) => RefEncoded<CoValue>,
+  getIdForKey: (key: Keys) => ID<CoValue> | undefined,
+  getKeysWithIds: () => Keys[],
+  controlledAccount: Account | AnonymousJazzAgent,
+  refSchemaForKey: (key: Keys) => RefEncoded<CoValue>,
 ): { [K in Keys]: Ref<CoValue> } & {
+  [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
+  length: number;
+} {
+  const refs = {} as { [K in Keys]: Ref<CoValue> } & {
     [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
     length: number;
-} {
-    const refs = {} as { [K in Keys]: Ref<CoValue> } & {
-        [Symbol.iterator]: () => IterableIterator<Ref<CoValue>>;
-        length: number;
-    };
-    return new Proxy(refs, {
-        get(_target, key) {
-            if (key === Symbol.iterator) {
-                return function* () {
-                    for (const key of getKeysWithIds()) {
-                        yield new Ref(
-                            getIdForKey(key)!,
-                            controlledAccount,
-                            refSchemaForKey(key),
-                        );
-                    }
-                };
-            }
-            if (typeof key === "symbol") return undefined;
-            if (key === "length") {
-                return getKeysWithIds().length;
-            }
-            const id = getIdForKey(key as Keys);
-            if (!id) return undefined;
-            return new Ref(
-                id as ID<CoValue>,
-                controlledAccount,
-                refSchemaForKey(key as Keys),
+  };
+  return new Proxy(refs, {
+    get(_target, key) {
+      if (key === Symbol.iterator) {
+        return function* () {
+          for (const key of getKeysWithIds()) {
+            yield new Ref(
+              getIdForKey(key)!,
+              controlledAccount,
+              refSchemaForKey(key),
             );
-        },
-        ownKeys() {
-            return getKeysWithIds().map((key) => key.toString());
-        },
-        getOwnPropertyDescriptor(target, key) {
-            const id = getIdForKey(key as Keys);
-            if (id) {
-                return {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                };
-            } else {
-                return Reflect.getOwnPropertyDescriptor(target, key);
-            }
-        },
-    });
+          }
+        };
+      }
+      if (typeof key === "symbol") return undefined;
+      if (key === "length") {
+        return getKeysWithIds().length;
+      }
+      const id = getIdForKey(key as Keys);
+      if (!id) return undefined;
+      return new Ref(
+        id as ID<CoValue>,
+        controlledAccount,
+        refSchemaForKey(key as Keys),
+      );
+    },
+    ownKeys() {
+      return getKeysWithIds().map((key) => key.toString());
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const id = getIdForKey(key as Keys);
+      if (id) {
+        return {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+        };
+      } else {
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      }
+    },
+  });
 }
 
 export type RefIfCoValue<V> = NonNullable<V> extends CoValue
-    ? Ref<UnCo<NonNullable<V>>>
-    : never;
+  ? Ref<UnCo<NonNullable<V>>>
+  : never;

package/src/implementation/schema.ts

@@ -1,182 +1,178 @@
 import type { JsonValue, RawCoValue } from "cojson";
+import { CoJsonValue } from "cojson/src/jsonValue.js";
 import {
-    type CoValue,
-    type CoValueClass,
-    isCoValueClass,
-    CoValueFromRaw,
-    SchemaInit,
-    ItemsSym,
-    MembersSym,
+  type CoValue,
+  type CoValueClass,
+  CoValueFromRaw,
+  ItemsSym,
+  MembersSym,
+  SchemaInit,
+  isCoValueClass,
 } from "../internal.js";
-import { CoJsonValue } from "cojson/src/jsonValue.js";
 
 /** @category Schema definition */
 export const Encoders = {
-    Date: {
-        encode: (value: Date) => value.toISOString(),
-        decode: (value: JsonValue) => new Date(value as string),
-    },
+  Date: {
+    encode: (value: Date) => value.toISOString(),
+    decode: (value: JsonValue) => new Date(value as string),
+  },
 };
 
 export type CoMarker = { readonly __co: unique symbol };
 /** @category Schema definition */
 export type co<T> = T | (T & CoMarker);
 export type IfCo<C, R> = C extends infer _A | infer B
-    ? B extends CoMarker
-        ? R
-        : never
-    : never;
+  ? B extends CoMarker
+    ? R
+    : never
+  : never;
 export type UnCo<T> = T extends co<infer A> ? A : T;
 
 const optional = {
-    ref: optionalRef,
-    json<T extends CoJsonValue<T>>(): co<T | undefined> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return { [SchemaInit]: "json" satisfies Schema } as any;
-    },
-    encoded<T>(arg: OptionalEncoder<T>): co<T | undefined> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
-    },
-    string: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<string | undefined>,
-    number: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<number | undefined>,
-    boolean: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<boolean | undefined>,
-    null: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<null | undefined>,
-    Date: {
-        [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
-    } as unknown as co<Date | undefined>,
-    literal<T extends (string | number | boolean)[]>(
-        ..._lit: T
-    ): co<T[number] | undefined> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return { [SchemaInit]: "json" satisfies Schema } as any;
-    },
+  ref: optionalRef,
+  json<T extends CoJsonValue<T>>(): co<T | undefined> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return { [SchemaInit]: "json" satisfies Schema } as any;
+  },
+  encoded<T>(arg: OptionalEncoder<T>): co<T | undefined> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
+  },
+  string: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<string | undefined>,
+  number: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<number | undefined>,
+  boolean: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<boolean | undefined>,
+  null: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<null | undefined>,
+  Date: {
+    [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
+  } as unknown as co<Date | undefined>,
+  literal<T extends (string | number | boolean)[]>(
+    ..._lit: T
+  ): co<T[number] | undefined> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return { [SchemaInit]: "json" satisfies Schema } as any;
+  },
 };
 
 /** @category Schema definition */
 export const co = {
-    string: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<string>,
-    number: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<number>,
-    boolean: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<boolean>,
-    null: {
-        [SchemaInit]: "json" satisfies Schema,
-    } as unknown as co<null>,
-    Date: {
-        [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
-    } as unknown as co<Date>,
-    literal<T extends (string | number | boolean)[]>(
-        ..._lit: T
-    ): co<T[number]> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return { [SchemaInit]: "json" satisfies Schema } as any;
-    },
-    json<T extends CoJsonValue<T>>(): co<T> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return { [SchemaInit]: "json" satisfies Schema } as any;
-    },
-    encoded<T>(arg: Encoder<T>): co<T> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
-    },
-    ref,
-    items: ItemsSym as ItemsSym,
-    members: MembersSym as MembersSym,
-    optional,
+  string: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<string>,
+  number: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<number>,
+  boolean: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<boolean>,
+  null: {
+    [SchemaInit]: "json" satisfies Schema,
+  } as unknown as co<null>,
+  Date: {
+    [SchemaInit]: { encoded: Encoders.Date } satisfies Schema,
+  } as unknown as co<Date>,
+  literal<T extends (string | number | boolean)[]>(..._lit: T): co<T[number]> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return { [SchemaInit]: "json" satisfies Schema } as any;
+  },
+  json<T extends CoJsonValue<T>>(): co<T> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return { [SchemaInit]: "json" satisfies Schema } as any;
+  },
+  encoded<T>(arg: Encoder<T>): co<T> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return { [SchemaInit]: { encoded: arg } satisfies Schema } as any;
+  },
+  ref,
+  items: ItemsSym as ItemsSym,
+  members: MembersSym as MembersSym,
+  optional,
 };
 
 function optionalRef<C extends CoValueClass>(
-    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
 ): co<InstanceType<C> | null | undefined> {
-    return ref(arg, { optional: true });
+  return ref(arg, { optional: true });
 }
 
 function ref<C extends CoValueClass>(
-    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
-    options?: never,
+  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  options?: never,
 ): co<InstanceType<C> | null>;
 function ref<C extends CoValueClass>(
-    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
-    options: { optional: true },
+  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  options: { optional: true },
 ): co<InstanceType<C> | null | undefined>;
 function ref<
-    C extends CoValueClass,
-    Options extends { optional?: boolean } | undefined,
+  C extends CoValueClass,
+  Options extends { optional?: boolean } | undefined,
 >(
-    arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
-    options?: Options,
+  arg: C | ((_raw: InstanceType<C>["_raw"]) => C),
+  options?: Options,
 ): Options extends { optional: true }
-    ? co<InstanceType<C> | null | undefined>
-    : co<InstanceType<C> | null> {
-    return {
-        [SchemaInit]: {
-            ref: arg,
-            optional: options?.optional || false,
-        } satisfies Schema,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } as any;
+  ? co<InstanceType<C> | null | undefined>
+  : co<InstanceType<C> | null> {
+  return {
+    [SchemaInit]: {
+      ref: arg,
+      optional: options?.optional || false,
+    } satisfies Schema,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any;
 }
 
 export type JsonEncoded = "json";
 export type EncodedAs<V> = { encoded: Encoder<V> | OptionalEncoder<V> };
 export type RefEncoded<V extends CoValue> = {
-    ref: CoValueClass<V> | ((raw: RawCoValue) => CoValueClass<V>);
-    optional: boolean;
+  ref: CoValueClass<V> | ((raw: RawCoValue) => CoValueClass<V>);
+  optional: boolean;
 };
 
 export function isRefEncoded<V extends CoValue>(
-    schema: Schema,
+  schema: Schema,
 ): schema is RefEncoded<V> {
-    return (
-        typeof schema === "object" &&
-        "ref" in schema &&
-        "optional" in schema &&
-        typeof schema.ref === "function"
-    );
+  return (
+    typeof schema === "object" &&
+    "ref" in schema &&
+    "optional" in schema &&
+    typeof schema.ref === "function"
+  );
 }
 
 export function instantiateRefEncoded<V extends CoValue>(
-    schema: RefEncoded<V>,
-    raw: RawCoValue,
+  schema: RefEncoded<V>,
+  raw: RawCoValue,
 ): V {
-    return isCoValueClass<V>(schema.ref)
-        ? schema.ref.fromRaw(raw)
-        : (
-              schema.ref as (
-                  raw: RawCoValue,
-              ) => CoValueClass<V> & CoValueFromRaw<V>
-          )(raw).fromRaw(raw);
+  return isCoValueClass<V>(schema.ref)
+    ? schema.ref.fromRaw(raw)
+    : (schema.ref as (raw: RawCoValue) => CoValueClass<V> & CoValueFromRaw<V>)(
+        raw,
+      ).fromRaw(raw);
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Schema = JsonEncoded | RefEncoded<CoValue> | EncodedAs<any>;
 
 export type SchemaFor<Field> = NonNullable<Field> extends CoValue
-    ? RefEncoded<NonNullable<Field>>
-    : NonNullable<Field> extends JsonValue
-      ? JsonEncoded
-      : EncodedAs<NonNullable<Field>>;
+  ? RefEncoded<NonNullable<Field>>
+  : NonNullable<Field> extends JsonValue
+    ? JsonEncoded
+    : EncodedAs<NonNullable<Field>>;
 
 export type Encoder<V> = {
-    encode: (value: V) => JsonValue;
-    decode: (value: JsonValue) => V;
-}
+  encode: (value: V) => JsonValue;
+  decode: (value: JsonValue) => V;
+};
 export type OptionalEncoder<V> =
-    | Encoder<V>
-    | {
-          encode: (value: V | undefined) => JsonValue;
-          decode: (value: JsonValue) => V | undefined;
-      };
+  | Encoder<V>
+  | {
+      encode: (value: V | undefined) => JsonValue;
+      decode: (value: JsonValue) => V | undefined;
+    };