jazz-tools 0.18.19 → 0.18.20

package/src/tools/implementation/zodSchema/zodReExport.ts

@@ -35,6 +35,7 @@ export {
   // record,
   // intersection,
   int,
+  codec,
   optional,
   array,
   tuple,

package/src/tools/tests/coList.test.ts

@@ -680,6 +680,40 @@ describe("CoList applyDiff operations", async () => {
     list.$jazz.applyDiff(["e", "c", "new", "y", "x"]);
     expect(list.$jazz.raw.asArray()).toEqual(["e", "c", "new", "y", "x"]);
   });
+
+  test("applyDiff should emit a single update", () => {
+    const TestMap = co.map({
+      type: z.string(),
+    });
+
+    const TestList = co.list(TestMap);
+
+    const bread = TestMap.create({ type: "bread" }, me);
+    const butter = TestMap.create({ type: "butter" }, me);
+    const onion = TestMap.create({ type: "onion" }, me);
+
+    const list = TestList.create([bread, butter, onion], me);
+
+    const updateFn = vi.fn();
+
+    const unsubscribe = TestList.subscribe(
+      list.$jazz.id,
+      {
+        resolve: {
+          $each: true,
+        },
+      },
+      updateFn,
+    );
+
+    updateFn.mockClear();
+
+    list.$jazz.applyDiff([bread]);
+
+    expect(updateFn).toHaveBeenCalledTimes(1);
+
+    unsubscribe();
+  });
 });
 
 describe("CoList resolution", async () => {

package/src/tools/tests/coPlainText.test.ts

@@ -1,6 +1,6 @@
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { Channel } from "queueueue";
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import {
   Account,
   cojsonInternals,
@@ -94,6 +94,30 @@ describe("CoPlainText", () => {
         text.$jazz.applyDiff(`😊👋 안녕!`);
         expect(text.toString()).toEqual(`😊👋 안녕!`);
       });
+
+      test("applyDiff should emit a single update", () => {
+        const Text = co.plainText();
+
+        const text = Text.create(`😊`, { owner: me });
+
+        const updateFn = vi.fn();
+
+        const unsubscribe = Text.subscribe(
+          text.$jazz.id,
+          {
+            loadAs: me,
+          },
+          updateFn,
+        );
+
+        updateFn.mockClear();
+
+        text.$jazz.applyDiff(`😊👋 안녕!`);
+
+        expect(updateFn).toHaveBeenCalledTimes(1);
+
+        unsubscribe();
+      });
     });
 
     describe("Properties", () => {

package/src/tools/tests/zod.test.ts

@@ -511,6 +511,137 @@ describe("co.map and Zod schema compatibility", () => {
       expect(map.readonly).toEqual({ name: "John" });
     });
   });
+
+  describe("Codec types", () => {
+    class DateRange {
+      constructor(
+        public start: Date,
+        public end: Date,
+      ) {}
+
+      isDateInRange(date: Date) {
+        return date >= this.start && date <= this.end;
+      }
+    }
+
+    const dateRangeCodec = z.codec(
+      z.tuple([z.string(), z.string()]),
+      z.z.instanceof(DateRange),
+      {
+        encode: (value) =>
+          [value.start.toISOString(), value.end.toISOString()] as [
+            string,
+            string,
+          ],
+        decode: ([start, end]) => {
+          return new DateRange(new Date(start), new Date(end));
+        },
+      },
+    );
+
+    it("should handle codec field", async () => {
+      const schema = co.map({
+        range: dateRangeCodec,
+      });
+
+      const map = schema.create({
+        range: new DateRange(new Date("2025-01-01"), new Date("2025-01-31")),
+      });
+
+      expect(map.range.isDateInRange(new Date("2025-01-15"))).toEqual(true);
+    });
+
+    it("should handle codec field with RegExp", async () => {
+      const schema = co.map({
+        regexp: z.codec(z.string(), z.z.instanceof(RegExp), {
+          encode: (value) => value.toString(),
+          decode: (value) => {
+            const [, pattern, flags] = value.match(/^\/(.*)\/([a-z]*)$/i)!;
+            if (!pattern) throw new Error("Invalid RegExp string");
+            return new RegExp(pattern, flags);
+          },
+        }),
+      });
+
+      const map = schema.create({
+        regexp: /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/,
+      });
+
+      expect(map.regexp.test("2001-01-31")).toEqual(true);
+    });
+
+    it("should handle optional codec field", async () => {
+      const schema = co.map({
+        range: dateRangeCodec.optional(),
+      });
+      const map = schema.create({});
+
+      expect(map.range).toBeUndefined();
+      expect(map.$jazz.has("range")).toEqual(false);
+    });
+
+    it("should handle nullable codec field", async () => {
+      const schema = co.map({
+        range: dateRangeCodec.nullable(),
+      });
+      const map = schema.create({ range: null });
+
+      expect(map.range).toBeNull();
+
+      map.$jazz.set(
+        "range",
+        new DateRange(new Date("2025-01-01"), new Date("2025-01-31")),
+      );
+      expect(map.range?.isDateInRange(new Date("2025-01-15"))).toEqual(true);
+    });
+
+    it("should handle nullish codec field", async () => {
+      const schema = co.map({
+        range: dateRangeCodec.nullish(),
+      });
+
+      const map = schema.create({});
+      expect(map.range).toBeUndefined();
+      expect(map.$jazz.has("range")).toEqual(false);
+
+      map.$jazz.set("range", undefined);
+      expect(map.range).toBeUndefined();
+      expect(map.$jazz.has("range")).toEqual(true);
+
+      map.$jazz.set("range", null);
+      expect(map.range).toBeNull();
+
+      map.$jazz.set(
+        "range",
+        new DateRange(new Date("2025-01-01"), new Date("2025-01-31")),
+      );
+      expect(map.range?.isDateInRange(new Date("2025-01-15"))).toEqual(true);
+    });
+
+    it("should not handle codec field with unsupported inner field", async () => {
+      const schema = co.map({
+        record: z.codec(
+          z.z.map(z.string(), z.string()),
+          z.z.record(z.string(), z.string()),
+          {
+            encode: (value) => new Map(Object.entries(value)),
+            decode: (value) => Object.fromEntries(value.entries()),
+          },
+        ),
+      });
+
+      expect(() =>
+        schema.create({
+          record: {
+            key1: "value1",
+            key2: "value2",
+          },
+        }),
+      ).toThrow(
+        "z.codec() is only supported if the input schema is already supported. Unsupported zod type: map",
+      );
+    });
+  });
 });
 
 describe("z.object() and CoValue schema compatibility", () => {