jazz-tools 0.8.14 → 0.8.16

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";

package/src/lib/cache.test.ts

@@ -1,64 +1,64 @@
-import { expect, describe, test } from "vitest";
-import { coValuesCache } from "./cache.js";
 import { RawCoValue } from "cojson";
+import { describe, expect, test } from "vitest";
 import { CoValue } from "../internal.js";
+import { coValuesCache } from "./cache.js";
 
 describe("coValuesCache", () => {
-    test("should return computed value when not cached", () => {
-        const mockRawValue = { type: "comap" } as RawCoValue;
-        const mockCoValue = { id: "test" } as unknown as CoValue;
-        let computeCalls = 0;
-
-        const result = coValuesCache.get(mockRawValue, () => {
-            computeCalls++;
-            return mockCoValue;
-        });
+  test("should return computed value when not cached", () => {
+    const mockRawValue = { type: "comap" } as RawCoValue;
+    const mockCoValue = { id: "test" } as unknown as CoValue;
+    let computeCalls = 0;
 
-        expect(result).toBe(mockCoValue);
-        expect(computeCalls).toBe(1);
+    const result = coValuesCache.get(mockRawValue, () => {
+      computeCalls++;
+      return mockCoValue;
     });
 
-    test("should return cached value on subsequent calls", () => {
-        const mockRawValue = { type: "comap" } as RawCoValue;
-        const mockCoValue = { id: "test" } as unknown as CoValue;
-        let computeCalls = 0;
+    expect(result).toBe(mockCoValue);
+    expect(computeCalls).toBe(1);
+  });
 
-        // First call
-        const result1 = coValuesCache.get(mockRawValue, () => {
-            computeCalls++;
-            return mockCoValue;
-        });
+  test("should return cached value on subsequent calls", () => {
+    const mockRawValue = { type: "comap" } as RawCoValue;
+    const mockCoValue = { id: "test" } as unknown as CoValue;
+    let computeCalls = 0;
 
-        // Second call with same raw value
-        const result2 = coValuesCache.get(mockRawValue, () => {
-            computeCalls++;
-            return mockCoValue;
-        });
+    // First call
+    const result1 = coValuesCache.get(mockRawValue, () => {
+      computeCalls++;
+      return mockCoValue;
+    });
 
-        expect(result1).toBe(mockCoValue);
-        expect(result2).toBe(mockCoValue);
-        expect(computeCalls).toBe(1); // Compute should only be called once
+    // Second call with same raw value
+    const result2 = coValuesCache.get(mockRawValue, () => {
+      computeCalls++;
+      return mockCoValue;
     });
 
-    test("should cache different values for different raw values", () => {
-        const mockRawValue1 = { type: "comap" } as RawCoValue;
-        const mockRawValue2 = { type: "colist" } as RawCoValue;
-        const mockCoValue1 = { id: "test1" } as unknown as CoValue;
-        const mockCoValue2 = { id: "test2" } as unknown as CoValue;
-        let computeCalls = 0;
+    expect(result1).toBe(mockCoValue);
+    expect(result2).toBe(mockCoValue);
+    expect(computeCalls).toBe(1); // Compute should only be called once
+  });
 
-        const result1 = coValuesCache.get(mockRawValue1, () => {
-            computeCalls++;
-            return mockCoValue1;
-        });
+  test("should cache different values for different raw values", () => {
+    const mockRawValue1 = { type: "comap" } as RawCoValue;
+    const mockRawValue2 = { type: "colist" } as RawCoValue;
+    const mockCoValue1 = { id: "test1" } as unknown as CoValue;
+    const mockCoValue2 = { id: "test2" } as unknown as CoValue;
+    let computeCalls = 0;
 
-        const result2 = coValuesCache.get(mockRawValue2, () => {
-            computeCalls++;
-            return mockCoValue2;
-        });
+    const result1 = coValuesCache.get(mockRawValue1, () => {
+      computeCalls++;
+      return mockCoValue1;
+    });
 
-        expect(result1).toBe(mockCoValue1);
-        expect(result2).toBe(mockCoValue2);
-        expect(computeCalls).toBe(2); // Should compute once for each unique raw value
+    const result2 = coValuesCache.get(mockRawValue2, () => {
+      computeCalls++;
+      return mockCoValue2;
     });
-});
+
+    expect(result1).toBe(mockCoValue1);
+    expect(result2).toBe(mockCoValue2);
+    expect(computeCalls).toBe(2); // Should compute once for each unique raw value
+  });
+});

package/src/lib/cache.ts

@@ -4,13 +4,13 @@ import { CoValue } from "../internal.js";
 const weakMap = new WeakMap<RawCoValue, CoValue>();
 
 export const coValuesCache = {
-    get: <V extends CoValue>(raw: RawCoValue, compute: () => V) => {
-        const cached = weakMap.get(raw);
-        if (cached) {
-            return cached as V;
-        }
-        const computed = compute();
-        weakMap.set(raw, computed);
-        return computed;
-    },
+  get: <V extends CoValue>(raw: RawCoValue, compute: () => V) => {
+    const cached = weakMap.get(raw);
+    if (cached) {
+      return cached as V;
+    }
+    const computed = compute();
+    weakMap.set(raw, computed);
+    return computed;
+  },
 };