jazz-tools 0.8.15 → 0.8.16

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