jazz-tools 0.18.19 → 0.18.21

package/src/svelte/Provider.svelte

@@ -1,59 +1,67 @@
-<script lang="ts" generics="S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema">
-import type { AuthSecretStorage, InstanceOfSchema } from "jazz-tools";
-import {
-  Account,
-  type AccountClass,
-  type AnyAccountSchema,
-  type CoValueFromRaw,
-} from "jazz-tools";
-import {
-  JazzBrowserContextManager,
-  type JazzContextManagerProps,
-} from "jazz-tools/browser";
-import { type Snippet, setContext, untrack } from "svelte";
-import { JAZZ_AUTH_CTX, JAZZ_CTX, type JazzContext } from "./jazz.svelte.js";
-
-let props: JazzContextManagerProps<S> & { children?: Snippet } = $props();
-
-const contextManager = new JazzBrowserContextManager<S>();
-
-const ctx = $state<JazzContext<InstanceOfSchema<S>>>({ current: undefined });
-
-setContext<JazzContext<InstanceOfSchema<S>>>(JAZZ_CTX, ctx);
-setContext<AuthSecretStorage>(
-  JAZZ_AUTH_CTX,
-  contextManager.getAuthSecretStorage(),
-);
-
-$effect(() => {
-  props.sync.when;
-  props.sync.peer;
-  props.storage;
-  props.guestMode;
-  return untrack(() => {
-    if (!props.sync) return;
-
-    contextManager
-      .createContext({
-        sync: props.sync,
-        storage: props.storage,
-        guestMode: props.guestMode,
-        AccountSchema: props.AccountSchema,
-        defaultProfileName: props.defaultProfileName,
-        onAnonymousAccountDiscarded: props.onAnonymousAccountDiscarded,
-        onLogOut: props.onLogOut,
-      })
-      .catch((error) => {
-        console.error("Error creating Jazz browser context:", error);
-      });
+<script
+  lang="ts"
+  generics="S extends (AccountClass<Account> & CoValueFromRaw<Account>) | AnyAccountSchema"
+>
+  import type { AuthSecretStorage, InstanceOfSchema } from "jazz-tools";
+  import {
+    Account,
+    type AccountClass,
+    type AnyAccountSchema,
+    type CoValueFromRaw,
+  } from "jazz-tools";
+  import {
+    JazzBrowserContextManager,
+    type JazzContextManagerProps,
+  } from "jazz-tools/browser";
+  import { type Snippet, setContext, untrack } from "svelte";
+  import { JAZZ_AUTH_CTX, JAZZ_CTX, type JazzContext } from "./jazz.svelte.js";
+
+  let props: JazzContextManagerProps<S> & {
+    children?: Snippet;
+    enableSSR?: boolean;
+  } = $props();
+
+  const contextManager = new JazzBrowserContextManager<S>({
+    useAnonymousFallback: props.enableSSR,
+  });
+
+  const ctx = $state<JazzContext<InstanceOfSchema<S>>>({ current: undefined });
+
+  setContext<JazzContext<InstanceOfSchema<S>>>(JAZZ_CTX, ctx);
+  setContext<AuthSecretStorage>(
+    JAZZ_AUTH_CTX,
+    contextManager.getAuthSecretStorage(),
+  );
+
+  $effect(() => {
+    props.sync.when;
+    props.sync.peer;
+    props.storage;
+    props.guestMode;
+    return untrack(() => {
+      if (!props.sync) return;
+
+      contextManager
+        .createContext({
+          sync: props.sync,
+          storage: props.storage,
+          guestMode: props.guestMode,
+          AccountSchema: props.AccountSchema,
+          defaultProfileName: props.defaultProfileName,
+          onAnonymousAccountDiscarded: props.onAnonymousAccountDiscarded,
+          onLogOut: props.onLogOut,
+        })
+        .catch((error) => {
+          console.error("Error creating Jazz browser context:", error);
+        });
+    });
   });
-});
 
-$effect(() => {
-  return contextManager.subscribe(() => {
-    ctx.current = contextManager.getCurrentValue();
+  $effect(() => {
+    return contextManager.subscribe(() => {
+      ctx.current = contextManager.getCurrentValue();
+    });
   });
-});
 </script>
 
 {#if ctx.current}

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/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/exports.ts

@@ -118,3 +118,5 @@ export {
   isJazzRequestError,
   type HttpRoute,
 } from "./coValues/request.js";
+
+export * from "./ssr/index.js";

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/ssr/index.ts

@@ -0,0 +1 @@
+export * from "./ssr.js";

package/src/tools/ssr/ssr.ts

@@ -0,0 +1,23 @@
+import { WebSocketPeerWithReconnection } from "cojson-transport-ws";
+import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+import { createAnonymousJazzContext } from "jazz-tools";
+
+export function createSSRJazzAgent(opts: { peer: string }) {
+  const ssrNode = createAnonymousJazzContext({
+    crypto: new PureJSCrypto(),
+    peersToLoadFrom: [],
+  });
+
+  const wsPeer = new WebSocketPeerWithReconnection({
+    peer: opts.peer,
+    reconnectionTimeout: 100,
+    addPeer: (peer) => {
+      ssrNode.agent.node.syncManager.addPeer(peer);
+    },
+    removePeer: () => {},
+  });
+
+  wsPeer.enable();
+
+  return ssrNode.agent;
+}

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

package/tsup.config.ts

@@ -16,6 +16,7 @@ export default defineConfig([
     entry: {
       index: "src/index.ts",
       testing: "src/testing.ts",
+      "tools/ssr": "src/tools/ssr/index.ts",
     },
     outDir: "dist",
   },
@@ -73,18 +74,12 @@ export default defineConfig([
     },
     outDir: "dist/prosemirror",
   },
-  {
-    ...cfg,
-    entry: {
-      ssr: "src/react/ssr.ts",
-    },
-    outDir: "dist/react",
-  },
   {
     ...cfg,
     entry: {
       index: "src/react/index.ts",
       testing: "src/react/testing.tsx",
+      ssr: "src/react/ssr.ts",
     },
     outDir: "dist/react",
     esbuildOptions: (options) => {