jazz-tools 0.8.15 → 0.8.16

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;
+    };

package/src/implementation/subscriptionScope.ts

@@ -1,148 +1,138 @@
 import type { RawCoValue } from "cojson";
 import type {
-    Account,
-    CoValue,
-    ID,
-    CoValueClass,
-    CoValueFromRaw,
-    AnonymousJazzAgent,
+  Account,
+  AnonymousJazzAgent,
+  CoValue,
+  CoValueClass,
+  CoValueFromRaw,
+  ID,
 } from "../internal.js";
 
 export const subscriptionsScopes = new WeakMap<
-    CoValue,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    SubscriptionScope<any>
+  CoValue,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  SubscriptionScope<any>
 >();
 
 const TRACE_INVALIDATIONS = false;
 
 export class SubscriptionScope<Root extends CoValue> {
-    scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
-    subscriber: Account | AnonymousJazzAgent;
-    entries = new Map<
-        ID<CoValue>,
-        | { state: "loading"; immediatelyUnsub?: boolean }
-        | { state: "loaded"; rawUnsub: () => void }
-    >();
-    rootEntry: {
-        state: "loaded";
-        value: RawCoValue;
-        rawUnsub: () => void;
+  scopeID: string = `scope-${Math.random().toString(36).slice(2)}`;
+  subscriber: Account | AnonymousJazzAgent;
+  entries = new Map<
+    ID<CoValue>,
+    | { state: "loading"; immediatelyUnsub?: boolean }
+    | { state: "loaded"; rawUnsub: () => void }
+  >();
+  rootEntry: {
+    state: "loaded";
+    value: RawCoValue;
+    rawUnsub: () => void;
+  };
+  scheduleUpdate: () => void;
+  scheduledUpdate: boolean = false;
+  cachedValues: { [id: ID<CoValue>]: CoValue } = {};
+  parents: { [id: ID<CoValue>]: Set<ID<CoValue>> } = {};
+
+  constructor(
+    root: Root,
+    rootSchema: CoValueClass<Root> & CoValueFromRaw<Root>,
+    onUpdate: (newRoot: Root) => void,
+  ) {
+    this.rootEntry = {
+      state: "loaded" as const,
+      value: root._raw,
+      rawUnsub: () => {}, // placeholder
     };
-    scheduleUpdate: () => void;
-    scheduledUpdate: boolean = false;
-    cachedValues: { [id: ID<CoValue>]: CoValue } = {};
-    parents: { [id: ID<CoValue>]: Set<ID<CoValue>> } = {};
+    this.entries.set(root.id, this.rootEntry);
 
-    constructor(
-        root: Root,
-        rootSchema: CoValueClass<Root> & CoValueFromRaw<Root>,
-        onUpdate: (newRoot: Root) => void,
-    ) {
-        this.rootEntry = {
-            state: "loaded" as const,
-            value: root._raw,
-            rawUnsub: () => {}, // placeholder
-        };
-        this.entries.set(root.id, this.rootEntry);
+    subscriptionsScopes.set(root, this);
 
-        subscriptionsScopes.set(root, this);
+    this.subscriber = root._loadedAs;
+    this.scheduleUpdate = () => {
+      const value = rootSchema.fromRaw(this.rootEntry.value) as Root;
+      subscriptionsScopes.set(value, this);
+      onUpdate(value);
+    };
 
-        this.subscriber = root._loadedAs;
-        this.scheduleUpdate = () => {
-            const value = rootSchema.fromRaw(this.rootEntry.value) as Root;
-            subscriptionsScopes.set(value, this);
-            onUpdate(value);
-        };
+    this.rootEntry.rawUnsub = root._raw.core.subscribe(
+      (rawUpdate: RawCoValue | undefined) => {
+        if (!rawUpdate) return;
+        this.rootEntry.value = rawUpdate;
+        this.scheduleUpdate();
+      },
+    );
+  }
 
-        this.rootEntry.rawUnsub = root._raw.core.subscribe(
-            (rawUpdate: RawCoValue | undefined) => {
-                if (!rawUpdate) return;
-                this.rootEntry.value = rawUpdate;
-                this.scheduleUpdate();
-            },
-        );
+  onRefAccessedOrSet(
+    fromId: ID<CoValue>,
+    accessedOrSetId: ID<CoValue> | undefined,
+  ) {
+    // console.log("onRefAccessedOrSet", this.scopeID, accessedOrSetId);
+    if (!accessedOrSetId) {
+      return;
     }
 
-    onRefAccessedOrSet(
-        fromId: ID<CoValue>,
-        accessedOrSetId: ID<CoValue> | undefined,
-    ) {
-        // console.log("onRefAccessedOrSet", this.scopeID, accessedOrSetId);
-        if (!accessedOrSetId) {
-            return;
-        }
-
-        this.parents[accessedOrSetId] =
-            this.parents[accessedOrSetId] || new Set();
-        this.parents[accessedOrSetId]!.add(fromId);
+    this.parents[accessedOrSetId] = this.parents[accessedOrSetId] || new Set();
+    this.parents[accessedOrSetId]!.add(fromId);
 
-        if (!this.entries.has(accessedOrSetId)) {
-            const loadingEntry = {
-                state: "loading",
-                immediatelyUnsub: false,
-            } as const;
-            this.entries.set(accessedOrSetId, loadingEntry);
-            const node =
-                this.subscriber._type === "Account"
-                    ? this.subscriber._raw.core.node
-                    : this.subscriber.node;
-            void node.loadCoValueCore(accessedOrSetId).then((core) => {
-                if (
-                    loadingEntry.state === "loading" &&
-                    loadingEntry.immediatelyUnsub
-                ) {
-                    return;
-                }
-                if (core !== "unavailable") {
-                    const entry = {
-                        state: "loaded" as const,
-                        rawUnsub: () => {}, // placeholder
-                    };
-                    this.entries.set(accessedOrSetId, entry);
+    if (!this.entries.has(accessedOrSetId)) {
+      const loadingEntry = {
+        state: "loading",
+        immediatelyUnsub: false,
+      } as const;
+      this.entries.set(accessedOrSetId, loadingEntry);
+      const node =
+        this.subscriber._type === "Account"
+          ? this.subscriber._raw.core.node
+          : this.subscriber.node;
+      void node.loadCoValueCore(accessedOrSetId).then((core) => {
+        if (loadingEntry.state === "loading" && loadingEntry.immediatelyUnsub) {
+          return;
+        }
+        if (core !== "unavailable") {
+          const entry = {
+            state: "loaded" as const,
+            rawUnsub: () => {}, // placeholder
+          };
+          this.entries.set(accessedOrSetId, entry);
 
-                    const rawUnsub = core.subscribe((rawUpdate) => {
-                        // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
-                        if (!rawUpdate) return;
-                        this.invalidate(accessedOrSetId);
-                        this.scheduleUpdate();
-                    });
+          const rawUnsub = core.subscribe((rawUpdate) => {
+            // console.log("ref update", this.scopeID, accessedOrSetId, JSON.stringify(rawUpdate))
+            if (!rawUpdate) return;
+            this.invalidate(accessedOrSetId);
+            this.scheduleUpdate();
+          });
 
-                    entry.rawUnsub = rawUnsub;
-                }
-            });
+          entry.rawUnsub = rawUnsub;
         }
+      });
     }
+  }
 
-    invalidate(
-        id: ID<CoValue>,
-        fromChild?: ID<CoValue>,
-        seen: Set<ID<CoValue>> = new Set(),
-    ) {
-        if (seen.has(id)) return;
-        TRACE_INVALIDATIONS &&
-            console.log(
-                "invalidating",
-                fromChild,
-                "->",
-                id,
-                this.cachedValues[id],
-            );
-        delete this.cachedValues[id];
-        seen.add(id);
-        for (const parent of this.parents[id] || []) {
-            this.invalidate(parent, id, seen);
-        }
+  invalidate(
+    id: ID<CoValue>,
+    fromChild?: ID<CoValue>,
+    seen: Set<ID<CoValue>> = new Set(),
+  ) {
+    if (seen.has(id)) return;
+    TRACE_INVALIDATIONS &&
+      console.log("invalidating", fromChild, "->", id, this.cachedValues[id]);
+    delete this.cachedValues[id];
+    seen.add(id);
+    for (const parent of this.parents[id] || []) {
+      this.invalidate(parent, id, seen);
     }
+  }
 
-    unsubscribeAll() {
-        for (const entry of this.entries.values()) {
-            if (entry.state === "loaded") {
-                entry.rawUnsub();
-            } else {
-                entry.immediatelyUnsub = true;
-            }
-        }
-        this.entries.clear();
+  unsubscribeAll() {
+    for (const entry of this.entries.values()) {
+      if (entry.state === "loaded") {
+        entry.rawUnsub();
+      } else {
+        entry.immediatelyUnsub = true;
+      }
     }
+    this.entries.clear();
+  }
 }

package/src/index.native.ts

@@ -1,7 +1,7 @@
 export * from "./exports.js";
 
 export {
-    cojsonInternals,
-    MAX_RECOMMENDED_TX_SIZE,
-    PureJSCrypto,
+  MAX_RECOMMENDED_TX_SIZE,
+  PureJSCrypto,
+  cojsonInternals,
 } from "cojson/native";