jazz-tools 0.18.18 → 0.18.20

package/src/tools/coValues/coList.ts

@@ -739,9 +739,20 @@ export class CoListJazzApi<L extends CoList> extends CoValueJazzApi<L> {
       : undefined;
 
     const patches = [...calcPatch(current, result, comparator)];
+
+    if (patches.length === 0) {
+      return this.coList;
+    }
+
+    // Turns off updates in the middle of applyDiff to improve the performance
+    this.raw.core.pauseNotifyUpdate();
+
     for (const [from, to, insert] of patches.reverse()) {
       this.splice(from, to - from, ...insert);
     }
+
+    this.raw.core.resumeNotifyUpdate();
+
     return this.coList;
   }
 

package/src/tools/coValues/coMap.ts

@@ -34,6 +34,7 @@ import {
   CoValueBase,
   CoValueJazzApi,
   ItemsSym,
+  NotNull,
   Ref,
   RegisteredSchemas,
   SchemaInit,
@@ -760,11 +761,10 @@ class CoMapJazzApi<M extends CoMap> extends CoValueJazzApi<M> {
         ? Key
         : never]?: RefIfCoValue<M[Key]>;
     } & {
-      [Key in CoKeys<M> as M[Key] extends undefined
-        ? never
-        : M[Key] extends CoValue
-          ? Key
-          : never]: RefIfCoValue<M[Key]>;
+      // Non-loaded CoValue refs (i.e. refs with type CoValue | null) are still required refs
+      [Key in CoKeys<M> as NotNull<M[Key]> extends CoValue
+        ? Key
+        : never]: RefIfCoValue<M[Key]>;
     }
   > {
     return makeRefs<CoKeys<this>>(

package/src/tools/coValues/coPlainText.ts

@@ -246,6 +246,13 @@ export class CoTextJazzApi<T extends CoPlainText> extends CoValueJazzApi<T> {
     // Calculate the diff on grapheme arrays
     const patches = [...calcPatch(currentGraphemes, otherGraphemes)];
 
+    if (patches.length === 0) {
+      return;
+    }
+
+    // Turns off updates in the middle of applyDiff to improve the performance
+    this.raw.core.pauseNotifyUpdate();
+
     // Apply patches in reverse order to avoid index shifting issues
     for (const [from, to, insert] of patches.reverse()) {
       if (to > from) {
@@ -256,6 +263,8 @@ export class CoTextJazzApi<T extends CoPlainText> extends CoValueJazzApi<T> {
         this.coText.insertBefore(from, this.raw.fromGraphemes(insert));
       }
     }
+
+    this.raw.core.resumeNotifyUpdate();
   }
 
   /**

package/src/tools/implementation/zodSchema/runtimeConverters/schemaFieldToCoFieldDef.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from "cojson";
 import { CoValueClass, isCoValueClass } from "../../../internal.js";
 import { coField } from "../../schema.js";
 import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
@@ -32,11 +33,31 @@ export type SchemaField =
   | z.core.$ZodLazy<z.core.$ZodType>
   | z.core.$ZodTemplateLiteral<any>
   | z.core.$ZodLiteral<any>
-  | z.core.$ZodCatch<z.core.$ZodType>
   | z.core.$ZodEnum<any>
+  | z.core.$ZodCodec<z.core.$ZodType, z.core.$ZodType>
   | z.core.$ZodDefault<z.core.$ZodType>
   | z.core.$ZodCatch<z.core.$ZodType>;
 
+function makeCodecCoField(
+  codec: z.core.$ZodCodec<z.core.$ZodType, z.core.$ZodType>,
+) {
+  return coField.optional.encoded({
+    encode: (value: any) => {
+      if (value === undefined) return undefined as unknown as JsonValue;
+      if (value === null) return null;
+      return codec._zod.def.reverseTransform(value, {
+        value,
+        issues: [],
+      }) as JsonValue;
+    },
+    decode: (value) => {
+      if (value === null) return null;
+      if (value === undefined) return undefined;
+      return codec._zod.def.transform(value, { value, issues: [] });
+    },
+  });
+}
+
 export function schemaFieldToCoFieldDef(schema: SchemaField) {
   if (isCoValueClass(schema)) {
     return coField.ref(schema);
@@ -54,7 +75,7 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
         zodSchemaDef.type === "optional" ||
         zodSchemaDef.type === "nullable"
       ) {
-        const inner = zodSchemaDef.innerType as ZodPrimitiveSchema;
+        const inner = zodSchemaDef.innerType as SchemaField;
         const coFieldDef: any = schemaFieldToCoFieldDef(inner);
         if (
           zodSchemaDef.type === "nullable" &&
@@ -137,6 +158,30 @@ export function schemaFieldToCoFieldDef(schema: SchemaField) {
             "z.union()/z.discriminatedUnion() of collaborative types is not supported. Use co.discriminatedUnion() instead.",
           );
         }
+      } else if (zodSchemaDef.type === "pipe") {
+        const isCodec =
+          zodSchemaDef.transform !== undefined &&
+          zodSchemaDef.reverseTransform !== undefined;
+
+        if (!isCodec) {
+          throw new Error(
+            "z.pipe() is not supported. Only z.codec() is supported.",
+          );
+        }
+
+        try {
+          schemaFieldToCoFieldDef(zodSchemaDef.in as SchemaField);
+        } catch (error) {
+          if (error instanceof Error) {
+            error.message = `z.codec() is only supported if the input schema is already supported. ${error.message}`;
+          }
+
+          throw error;
+        }
+
+        return makeCodecCoField(
+          schema as z.core.$ZodCodec<z.core.$ZodType, z.core.$ZodType>,
+        );
       } else {
         throw new Error(
           `Unsupported zod type: ${(schema._zod?.def as any)?.type || JSON.stringify(schema)}`,

package/src/tools/implementation/zodSchema/typeConverters/TypeOfZodSchema.ts

@@ -71,8 +71,13 @@ export type TypeOfZodSchema<S extends z.core.$ZodType> =
                                       infer Default extends z.core.$ZodType
                                     >
                                   ? TypeOfZodSchema<Default>
-                                  : S extends z.core.$ZodCatch<
-                                        infer Catch extends z.core.$ZodType
+                                  : S extends z.core.$ZodCodec<
+                                        any,
+                                        infer Out extends z.core.$ZodType
                                       >
-                                    ? TypeOfZodSchema<Catch>
-                                    : never;
+                                    ? Out["_zod"]["output"]
+                                    : S extends z.core.$ZodCatch<
+                                          infer Catch extends z.core.$ZodType
+                                        >
+                                      ? TypeOfZodSchema<Catch>
+                                      : never;

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

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

package/src/tools/subscribe/index.ts

@@ -18,7 +18,7 @@ export function getSubscriptionScope<D extends CoValue>(value: D) {
   });
 
   Object.defineProperty(value.$jazz, "_subscriptionScope", {
-    value: subscriptionScope,
+    value: newSubscriptionScope,
     writable: false,
     enumerable: false,
     configurable: false,

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/coMap.test.ts

@@ -1150,6 +1150,30 @@ describe("CoMap resolution", async () => {
     });
   });
 
+  test("obtaining coMap refs", async () => {
+    const Dog = co.map({
+      name: z.string().optional(),
+      breed: z.string(),
+      owner: co.plainText(),
+      get parent() {
+        return co.optional(Dog);
+      },
+    });
+
+    const dog = Dog.create({
+      name: "Rex",
+      breed: "Labrador",
+      owner: "John",
+      parent: { name: "Fido", breed: "Labrador", owner: "Jane" },
+    });
+
+    const refs = dog.$jazz.refs;
+
+    expect(Object.keys(refs)).toEqual(["owner", "parent"]);
+    expect(refs.owner.id).toEqual(dog.owner.$jazz.id);
+    expect(refs.parent?.id).toEqual(dog.parent!.$jazz.id);
+  });
+
   test("accessing the value refs", async () => {
     const Dog = co.map({
       name: z.string(),
@@ -1181,9 +1205,9 @@ describe("CoMap resolution", async () => {
 
     assert(loadedPerson);
 
-    expect(loadedPerson.$jazz.refs.dog?.id).toBe(person.dog!.$jazz.id);
+    expect(loadedPerson.$jazz.refs.dog.id).toBe(person.dog.$jazz.id);
 
-    const dog = await loadedPerson.$jazz.refs.dog?.load();
+    const dog = await loadedPerson.$jazz.refs.dog.load();
 
     assert(dog);
 

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/subscribe.test.ts

@@ -20,6 +20,7 @@ import {
   setupJazzTestSync,
 } from "../testing.js";
 import { setupAccount, waitFor } from "./utils.js";
+import { getSubscriptionScope } from "../subscribe/index.js";
 
 cojsonInternals.setCoValueLoadingRetryDelay(300);
 
@@ -1278,3 +1279,43 @@ describe("subscribeToCoValue", () => {
     expect(result.data[chunks]).toBe("new entry");
   });
 });
+
+describe("getSubscriptionScope", () => {
+  const Person = co.map({
+    name: z.string(),
+  });
+  let person: co.output<typeof Person>;
+
+  beforeEach(async () => {
+    await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+      creationProps: { name: "Hermes Puggington" },
+    });
+
+    person = Person.create({ name: "John" });
+  });
+
+  describe("when the coValue doesn't have a subscription scope", () => {
+    it("creates a new subscription scope", () => {
+      expect(person.$jazz._subscriptionScope).toBeUndefined();
+      const subscriptionScope = getSubscriptionScope(person);
+      expect(subscriptionScope).toBeDefined();
+    });
+
+    it("updates the subscription scope in the coValue", () => {
+      const subscriptionScope = getSubscriptionScope(person);
+      expect(person.$jazz._subscriptionScope).toBeDefined();
+      expect(person.$jazz._subscriptionScope).toBe(subscriptionScope);
+    });
+  });
+
+  describe("when the coValue already has a subscription scope", () => {
+    it("returns that subscription scope", async () => {
+      const loadedPerson = await Person.load(person.$jazz.id);
+      assert(loadedPerson);
+      const subscriptionScope = loadedPerson.$jazz._subscriptionScope;
+      expect(subscriptionScope).toBeDefined();
+      expect(getSubscriptionScope(loadedPerson)).toBe(subscriptionScope);
+    });
+  });
+});

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", () => {