jazz-tools 0.17.7 → 0.17.9

package/src/prosemirror/tests/plugin.test.ts

@@ -1,29 +1,33 @@
 // @vitest-environment jsdom
 
-import { Account, CoRichText } from "jazz-tools";
+import { CoRichText } from "jazz-tools";
 import { createJazzTestAccount, setupJazzTestSync } from "jazz-tools/testing";
-import { schema } from "prosemirror-schema-basic";
 import { EditorState, TextSelection } from "prosemirror-state";
-import { Plugin } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  onTestFinished,
+} from "vitest";
 import { createJazzPlugin } from "../lib/plugin";
+import { Schema } from "prosemirror-model";
+import { schema as basicSchema } from "prosemirror-schema-basic";
+import { addListNodes } from "prosemirror-schema-list";
 
-let account: Account;
-let coRichText: CoRichText;
-let plugin: Plugin;
-let state: EditorState;
-let view: EditorView;
-
-beforeEach(async () => {
-  await setupJazzTestSync();
-  account = await createJazzTestAccount({ isCurrentActiveAccount: true });
+const schema = new Schema({
+  nodes: addListNodes(basicSchema.spec.nodes, "paragraph block*", "block"),
+  marks: basicSchema.spec.marks,
+});
 
+async function setupTest(initialContent = "<p>Hello</p>") {
   // Create a real CoRichText with the test account as owner
-  coRichText = CoRichText.create("<p>Hello</p>", account);
+  const coRichText = CoRichText.create(initialContent);
 
-  plugin = createJazzPlugin(coRichText);
-  state = EditorState.create({
+  const plugin = createJazzPlugin(coRichText);
+  const state = EditorState.create({
     schema,
     plugins: [plugin],
   });
@@ -33,25 +37,32 @@ beforeEach(async () => {
   document.body.appendChild(editorElement);
 
   // Initialize the editor view
-  view = new EditorView(editorElement, {
+  const view = new EditorView(editorElement, {
     state,
   });
-});
 
-afterEach(() => {
-  // Clean up the editor view
-  if (view) {
+  onTestFinished(() => {
     view.destroy();
-    view.dom.remove();
-  }
+    editorElement.remove();
+  });
+
+  return { coRichText, plugin, state, view, editorElement };
+}
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+  await createJazzTestAccount({ isCurrentActiveAccount: true });
 });
 
 describe("createJazzPlugin", () => {
-  it("initializes editor with CoRichText content", () => {
+  it("initializes editor with CoRichText content", async () => {
+    const { state } = await setupTest();
     expect(state.doc.textContent).toContain("Hello");
   });
 
   it("updates editor when CoRichText changes", async () => {
+    const { coRichText, view } = await setupTest();
+
     // Update CoRichText content
     coRichText.applyDiff("<p>Updated content</p>");
 
@@ -61,7 +72,9 @@ describe("createJazzPlugin", () => {
     expect(view.state.doc.textContent).toContain("Updated content");
   });
 
-  it("updates CoRichText when editor content changes", () => {
+  it("updates CoRichText when editor content changes", async () => {
+    const { coRichText, view } = await setupTest();
+
     // Create a transaction to update the editor content
     const tr = view.state.tr.insertText(" World", 6);
     view.dispatch(tr);
@@ -70,8 +83,8 @@ describe("createJazzPlugin", () => {
     expect(coRichText.toString()).toContain("Hello World");
   });
 
-  it("handles empty CoRichText initialization", () => {
-    const emptyCoRichText = CoRichText.create("", account);
+  it("handles empty CoRichText initialization", async () => {
+    const emptyCoRichText = CoRichText.create("");
     const emptyPlugin = createJazzPlugin(emptyCoRichText);
     const emptyState = EditorState.create({
       schema,
@@ -81,7 +94,7 @@ describe("createJazzPlugin", () => {
     expect(emptyState.doc.textContent).toBe("");
   });
 
-  it("handles undefined CoRichText", () => {
+  it("handles undefined CoRichText", async () => {
     const undefinedPlugin = createJazzPlugin(undefined);
     const undefinedState = EditorState.create({
       schema,
@@ -91,7 +104,9 @@ describe("createJazzPlugin", () => {
     expect(undefinedState.doc.textContent).toBe("");
   });
 
-  it("prevents infinite update loops", () => {
+  it("prevents infinite update loops", async () => {
+    const { coRichText, view } = await setupTest();
+
     // Create a transaction that would normally trigger a CoRichText update
     const tr = view.state.tr.insertText(" Loop", 6);
 
@@ -106,7 +121,9 @@ describe("createJazzPlugin", () => {
     expect(coRichText.toString()).not.toContain("Loop");
   });
 
-  it.skip("preserves selection when CoRichText changes", () => {
+  it("preserves selection when CoRichText changes", async () => {
+    const { coRichText, view } = await setupTest();
+
     // Set a selection in the editor
     const tr = view.state.tr.setSelection(
       TextSelection.create(view.state.doc, 2, 5),
@@ -118,10 +135,49 @@ describe("createJazzPlugin", () => {
     expect(view.state.selection.to).toBe(5);
 
     // Update CoRichText content
-    coRichText.applyDiff("<p>Updated content</p>");
+    coRichText.applyDiff("<p>Hello world</p>");
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
 
     // Verify selection is preserved after content update
     expect(view.state.selection.from).toBe(2);
     expect(view.state.selection.to).toBe(5);
   });
+
+  it("falls back to creating a new EditorState when the transform fails", async () => {
+    const { coRichText, editorElement } = await setupTest(
+      "<p>A <strong>hu<em>man</strong></em>.</p>",
+    );
+
+    // Wait for the next tick to allow the update to propagate
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    // Update CoRichText content
+    coRichText.applyDiff(
+      "<ol><li><p>A <strong>hu</strong><em><strong>man</strong></em>.</p></li></ol>",
+    );
+
+    // Wait for the next tick to allow the update to propagate
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(editorElement.querySelector(".ProseMirror")?.innerHTML).toBe(
+      "<ol><li><p>A <strong>hu</strong><em><strong>man</strong></em>.</p></li></ol>",
+    );
+  });
+
+  it("handles updates with emojis", async () => {
+    const { coRichText, editorElement } = await setupTest(
+      "<p>A <strong>hu</strong><em><strong>man</strong></em>.</p>",
+    );
+
+    // Update CoRichText content
+    coRichText.applyDiff("<p>A human💪</p>");
+
+    // Wait for the next tick to allow the update to propagate
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(editorElement.querySelector(".ProseMirror")?.innerHTML).toBe(
+      "<p>A human💪</p>",
+    );
+  });
 });

package/src/react/auth/Clerk.tsx

@@ -9,7 +9,7 @@ import {
 } from "jazz-tools";
 import { LocalStorageKVStore } from "jazz-tools/browser";
 import { useAuthSecretStorage, useJazzContext } from "jazz-tools/react-core";
-import { useEffect, useMemo, useState } from "react";
+import { ReactNode, useEffect, useMemo, useState } from "react";
 import { JazzProviderProps, JazzReactProvider } from "../provider.js";
 
 function useJazzClerkAuth(clerk: MinimalClerkClient) {
@@ -43,7 +43,9 @@ export const JazzReactProviderWithClerk = <
     | (AccountClass<Account> & CoValueFromRaw<Account>)
     | AnyAccountSchema,
 >(
-  props: { clerk: MinimalClerkClient } & JazzProviderProps<S>,
+  props: {
+    clerk: MinimalClerkClient;
+  } & JazzProviderProps<S>,
 ) => {
   const [isLoaded, setIsLoaded] = useState(false);
 
@@ -61,7 +63,7 @@ export const JazzReactProviderWithClerk = <
   }, []);
 
   if (!isLoaded) {
-    return null;
+    return props.fallback ?? null;
   }
 
   return (

package/src/react/provider.tsx

@@ -20,6 +20,7 @@ export type JazzProviderProps<
 > = {
   children: React.ReactNode;
   enableSSR?: boolean;
+  fallback?: React.ReactNode | null;
 } & JazzContextManagerProps<S>;
 
 /** @category Context & Hooks */
@@ -38,6 +39,7 @@ export function JazzReactProvider<
   logOutReplacement,
   onAnonymousAccountDiscarded,
   enableSSR,
+  fallback = null,
 }: JazzProviderProps<S>) {
   const [contextManager] = React.useState(
     () =>
@@ -100,7 +102,7 @@ export function JazzReactProvider<
   return (
     <JazzContext.Provider value={value}>
       <JazzContextManagerContext.Provider value={contextManager}>
-        {value && children}
+        {value ? children : fallback}
       </JazzContextManagerContext.Provider>
     </JazzContext.Provider>
   );

package/src/tools/coValues/coMap.ts

@@ -628,7 +628,11 @@ export class CoMap extends CoValueBase implements CoValue {
       resolve?: RefsToResolveStrict<M, R>;
     },
   ): Promise<Resolved<M, R> | null> {
-    let mapId = CoMap._findUnique(options.unique, options.owner.id);
+    const mapId = CoMap._findUnique(
+      options.unique,
+      options.owner.id,
+      options.owner._loadedAs,
+    );
     let map: Resolved<M, R> | null = await loadCoValueWithoutMe(this, mapId, {
       ...options,
       loadAs: options.owner._loadedAs,

package/src/tools/exports.ts

@@ -35,6 +35,7 @@ export type {
   TextPos,
   AccountClass,
   AccountCreationProps,
+  BaseProfileShape,
 } from "./internal.js";
 
 export {

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

@@ -38,9 +38,14 @@ import {
 // Note: if you're editing this function, edit the `isAnyCoValueSchema`
 // function in `zodReExport.ts` as well
 export function isAnyCoValueSchema(
-  schema: AnyZodOrCoValueSchema | CoValueClass,
+  schema: unknown,
 ): schema is AnyCoreCoValueSchema {
-  return "collaborative" in schema && schema.collaborative === true;
+  return (
+    typeof schema === "object" &&
+    schema !== null &&
+    "collaborative" in schema &&
+    schema.collaborative === true
+  );
 }
 
 export function isCoValueSchema(

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

@@ -19,6 +19,7 @@ import {
   createCoreCoPlainTextSchema,
   createCoreFileStreamSchema,
   hydrateCoreCoValueSchema,
+  isAnyCoValueSchema,
 } from "../../internal.js";
 import {
   CoDiscriminatedUnionSchema,
@@ -36,6 +37,11 @@ import { z } from "./zodReExport.js";
 export const coMapDefiner = <Shape extends z.core.$ZodLooseShape>(
   shape: Shape,
 ): CoMapSchema<Shape> => {
+  if (isAnyCoValueSchema(shape as any)) {
+    throw new Error(
+      "co.map() expects an object as its argument, not a CoValue schema",
+    );
+  }
   const coreSchema = createCoreCoMapSchema(shape);
   return hydrateCoreCoValueSchema(coreSchema);
 };
@@ -116,6 +122,11 @@ export const coProfileDefiner = <
 >(
   shape: Shape & Partial<DefaultProfileShape> = {} as any,
 ): CoProfileSchema<Shape> => {
+  if (isAnyCoValueSchema(shape as any)) {
+    throw new Error(
+      "co.profile() expects an object as its argument, not a CoValue schema",
+    );
+  }
   const ehnancedShape = Object.assign(shape, {
     name: z.string(),
     inbox: z.optional(z.string()),

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

@@ -88,6 +88,11 @@ function containsCoValueSchema(shape?: core.$ZodLooseShape): boolean {
 
 // Note: if you're editing this function, edit the `isAnyCoValueSchema`
 // function in `zodSchemaToCoSchema.ts` as well
-function isAnyCoValueSchema(schema: any): boolean {
-  return "collaborative" in schema && schema.collaborative === true;
+function isAnyCoValueSchema(schema: unknown): boolean {
+  return (
+    typeof schema === "object" &&
+    schema !== null &&
+    "collaborative" in schema &&
+    schema.collaborative === true
+  );
 }

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

@@ -137,6 +137,12 @@ test("loading raw accounts should work", async () => {
   expect(loadedAccount.profile!.name).toBe("test 1");
 });
 
+test("co.profile() should throw an error if passed a CoValue schema", async () => {
+  expect(() => co.profile(co.map({}))).toThrow(
+    "co.profile() expects an object as its argument, not a CoValue schema",
+  );
+});
+
 test("should support recursive props on co.profile", async () => {
   const User = co.profile({
     name: z.string(),

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

@@ -2325,6 +2325,12 @@ describe("co.map schema", () => {
       expect(draftPerson.extraField).toEqual("extra");
     });
   });
+
+  test("co.map() should throw an error if passed a CoValue schema", () => {
+    expect(() => co.map(co.map({}))).toThrow(
+      "co.map() expects an object as its argument, not a CoValue schema",
+    );
+  });
 });
 
 describe("Updating a nested reference", () => {