jazz-tools 0.17.14 → 0.18.1

package/src/media/utils.test.ts

@@ -28,104 +28,104 @@ describe("highestResAvailable", async () => {
   });
 
   it("returns original if progressive is false", async () => {
-    const original = await createFileStream(account._owner);
+    const original = await createFileStream(account.$jazz.owner);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [1920, 1080],
         progressive: false,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["1920x1080"] = original;
+    imageDef.$jazz.set("1920x1080", original);
 
     const result = highestResAvailable(imageDef, 256, 256);
-    expect(result?.image.id).toBe(original.id);
+    expect(result?.image.$jazz.id).toBe(original.$jazz.id);
   });
 
   it("returns original if progressive is true but no resizes present", async () => {
-    const original = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner, 1);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [1920, 1080],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["1920x1080"] = original;
+    imageDef.$jazz.set("1920x1080", original);
 
     const result = highestResAvailable(imageDef, 256, 256);
-    expect(result?.image.id).toBe(original.id);
+    expect(result?.image.$jazz.id).toBe(original.$jazz.id);
   });
 
   it("returns closest available resize if progressive is true", async () => {
-    const original = await createFileStream(account._owner);
-    const resize256 = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner);
+    const resize256 = await createFileStream(account.$jazz.owner, 1);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [1920, 1080],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["1920x1080"] = original;
-    imageDef["256x256"] = resize256;
+    imageDef.$jazz.set("1920x1080", original);
+    imageDef.$jazz.set("256x256", resize256);
 
     const result = highestResAvailable(imageDef, 256, 256);
-    expect(result?.image.id).toBe(resize256.id);
+    expect(result?.image.$jazz.id).toBe(resize256.$jazz.id);
   });
 
   it("returns original if wanted size matches original size", async () => {
-    const original = await createFileStream(account._owner);
+    const original = await createFileStream(account.$jazz.owner);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [1024, 1024],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["1024x1024"] = original;
+    imageDef.$jazz.set("1024x1024", original);
 
     const result = highestResAvailable(imageDef, 1024, 1024);
-    expect(result?.image.id).toBe(original.id);
+    expect(result?.image.$jazz.id).toBe(original.$jazz.id);
   });
 
   it("returns best fit among multiple resizes", async () => {
-    const original = await createFileStream(account._owner);
-    const resize256 = await createFileStream(account._owner, 1);
-    const resize1024 = await createFileStream(account._owner, 1);
-    const resize2048 = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner);
+    const resize256 = await createFileStream(account.$jazz.owner, 1);
+    const resize1024 = await createFileStream(account.$jazz.owner, 1);
+    const resize2048 = await createFileStream(account.$jazz.owner, 1);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [2048, 2048],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["256x256"] = resize256;
-    imageDef["1024x1024"] = resize1024;
-    imageDef["2048x2048"] = resize2048;
+    imageDef.$jazz.set("256x256", resize256);
+    imageDef.$jazz.set("1024x1024", resize1024);
+    imageDef.$jazz.set("2048x2048", resize2048);
 
     // Closest to 900x900 is 1024
     const result = highestResAvailable(imageDef, 900, 900);
-    expect(result?.image.id).toBe(resize1024.id);
+    expect(result?.image.$jazz.id).toBe(resize1024.$jazz.id);
   });
 
   it("returns the best fit resolution", async () => {
-    const original = await createFileStream(account._owner, 1);
-    const resize256 = await createFileStream(account._owner, 1);
-    const resize2048 = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner, 1);
+    const resize256 = await createFileStream(account.$jazz.owner, 1);
+    const resize2048 = await createFileStream(account.$jazz.owner, 1);
     // 1024 is not loaded yet
-    const resize1024 = FileStream.create({ owner: account._owner });
+    const resize1024 = FileStream.create({ owner: account.$jazz.owner });
     resize1024.start({ mimeType: "image/jpeg" });
     // Don't end resize1024, so it has no chunks
 
@@ -135,42 +135,42 @@ describe("highestResAvailable", async () => {
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
-    imageDef["256x256"] = resize256;
-    imageDef["1024x1024"] = resize1024;
-    imageDef["2048x2048"] = resize2048;
+    imageDef.$jazz.set("256x256", resize256);
+    imageDef.$jazz.set("1024x1024", resize1024);
+    imageDef.$jazz.set("2048x2048", resize2048);
 
     // Closest to 900x900 is 1024
     const result = highestResAvailable(imageDef, 900, 900);
-    expect(result?.image.id).toBe(resize2048.id);
+    expect(result?.image.$jazz.id).toBe(resize2048.$jazz.id);
   });
 
   it("returns original if no resizes are loaded (missing chunks)", async () => {
-    const original = await createFileStream(account._owner);
+    const original = await createFileStream(account.$jazz.owner);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [256, 256],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["256x256"] = original;
+    imageDef.$jazz.set("256x256", original);
     // 1024 is not loaded yet
-    const resize1024 = FileStream.create({ owner: account._owner });
+    const resize1024 = FileStream.create({ owner: account.$jazz.owner });
     resize1024.start({ mimeType: "image/jpeg" });
     // Don't end resize1024, so it has no chunks
-    imageDef["1024x1024"] = resize1024;
+    imageDef.$jazz.set("1024x1024", resize1024);
 
     const result = highestResAvailable(imageDef, 1024, 1024);
     // Only original is valid
-    expect(result?.image.id).toBe(original.id);
+    expect(result?.image.$jazz.id).toBe(original.$jazz.id);
   });
 
   it("returns the first loaded resize if original is not loaded yet(missing chunks)", async () => {
-    const original = FileStream.create({ owner: account._owner });
+    const original = FileStream.create({ owner: account.$jazz.owner });
     original.start({ mimeType: "image/jpeg" });
     // Don't call .end(), so it has no chunks
 
@@ -180,18 +180,21 @@ describe("highestResAvailable", async () => {
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["256x256"] = await createFileStream(account._owner, 1);
+    imageDef.$jazz.set(
+      "256x256",
+      await createFileStream(account.$jazz.owner, 1),
+    );
 
     const result = highestResAvailable(imageDef, 1024, 1024);
     // Only original is valid
-    expect(result?.image.id).toBe(imageDef["256x256"].id);
+    expect(result?.image.$jazz.id).toBe(imageDef["256x256"]!.$jazz.id);
   });
 
   it("returns the highest resolution if no good match is found", async () => {
-    const original = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner, 1);
 
     const imageDef = ImageDefinition.create(
       {
@@ -199,14 +202,17 @@ describe("highestResAvailable", async () => {
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
 
-    imageDef["256x256"] = await createFileStream(account._owner, 1);
-    imageDef["300x300"] = original;
+    imageDef.$jazz.set(
+      "256x256",
+      await createFileStream(account.$jazz.owner, 1),
+    );
+    imageDef.$jazz.set("300x300", original);
 
     const result = highestResAvailable(imageDef, 1024, 1024);
-    expect(result?.image.id).toBe(original.id);
+    expect(result?.image.$jazz.id).toBe(original.$jazz.id);
   });
 });
 
@@ -237,12 +243,12 @@ describe("loadImageBySize", async () => {
       },
       { owner },
     );
-    imageDef[`${originalSize[0]}x${originalSize[1]}`] = original;
+    imageDef.$jazz.set(`${originalSize[0]}x${originalSize[1]}`, original);
 
     for (const size of sizes) {
       if (!size) continue;
       const [w, h] = size;
-      imageDef[`${w}x${h}`] = await createFileStream(owner, 1);
+      imageDef.$jazz.set(`${w}x${h}`, await createFileStream(owner, 1));
     }
     return imageDef;
   };
@@ -250,7 +256,7 @@ describe("loadImageBySize", async () => {
   it("returns original if progressive is false", async () => {
     const imageDef = await createImageDef([[1920, 1080]], false);
     const result = await loadImageBySize(imageDef, 256, 256);
-    expect(result?.image.id).toBe(imageDef["1920x1080"]!.id);
+    expect(result?.image.$jazz.id).toBe(imageDef["1920x1080"]!.$jazz.id);
   });
 
   it("returns the original image already loaded", async () => {
@@ -266,20 +272,20 @@ describe("loadImageBySize", async () => {
     setActiveAccount(account2);
 
     const result = await loadImageBySize(imageDef, 256, 256);
-    expect(result?.image.id).toBe(imageDef["1920x1080"]!.id);
+    expect(result?.image.$jazz.id).toBe(imageDef["1920x1080"]!.$jazz.id);
     expect(result?.image.isBinaryStreamEnded()).toBe(true);
     expect(result?.image.asBase64()).toStrictEqual(expect.any(String));
   });
 
   it("returns null if no sizes are available", async () => {
-    const original = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner, 1);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [1920, 1080],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
     const result = await loadImageBySize(imageDef, 256, 256);
     expect(result).toBeNull();
@@ -290,8 +296,8 @@ describe("loadImageBySize", async () => {
       [256, 256],
       [1920, 1080],
     ]);
-    const result = await loadImageBySize(imageDef.id, 256, 256);
-    expect(result?.image.id).toBe(imageDef["256x256"]!.id);
+    const result = await loadImageBySize(imageDef.$jazz.id, 256, 256);
+    expect(result?.image.$jazz.id).toBe(imageDef["256x256"]!.$jazz.id);
     expect(result?.width).toBe(256);
     expect(result?.height).toBe(256);
   });
@@ -303,7 +309,7 @@ describe("loadImageBySize", async () => {
       [2048, 2048],
     ]);
     const result = await loadImageBySize(imageDef, 900, 900);
-    expect(result?.image.id).toBe(imageDef["1024x1024"]!.id);
+    expect(result?.image.$jazz.id).toBe(imageDef["1024x1024"]!.$jazz.id);
     expect(result?.width).toBe(1024);
     expect(result?.height).toBe(1024);
   });
@@ -314,20 +320,20 @@ describe("loadImageBySize", async () => {
       [300, 300],
     ]);
     const result = await loadImageBySize(imageDef, 1024, 1024);
-    expect(result?.image.id).toBe(imageDef["300x300"]!.id);
+    expect(result?.image.$jazz.id).toBe(imageDef["300x300"]!.$jazz.id);
     expect(result?.width).toBe(300);
     expect(result?.height).toBe(300);
   });
 
   it("returns null if the best target is not loaded", async () => {
-    const original = await createFileStream(account._owner, 1);
+    const original = await createFileStream(account.$jazz.owner, 1);
     const imageDef = ImageDefinition.create(
       {
         originalSize: [256, 256],
         progressive: true,
         original,
       },
-      { owner: account._owner },
+      { owner: account.$jazz.owner },
     );
     // No resizes added
     const result = await loadImageBySize(imageDef, 1024, 1024);
@@ -340,7 +346,7 @@ describe("loadImageBySize", async () => {
       [1024, 1024],
     ]);
     const result = await loadImageBySize(imageDef, 1024, 1024);
-    expect(result?.image.id).toBe(imageDef["1024x1024"]!.id);
+    expect(result?.image.$jazz.id).toBe(imageDef["1024x1024"]!.$jazz.id);
     expect(result?.width).toBe(1024);
     expect(result?.height).toBe(1024);
   });
@@ -365,9 +371,9 @@ describe("loadImageBySize", async () => {
     const account2 = await createJazzTestAccount();
     setActiveAccount(account2);
 
-    const result = await loadImageBySize(imageDef.id, 1024, 1024);
+    const result = await loadImageBySize(imageDef.$jazz.id, 1024, 1024);
     expect(result).not.toBeNull();
-    expect(result?.image.id).toBe(imageDef["1024x1024"]!.id);
+    expect(result?.image.$jazz.id).toBe(imageDef["1024x1024"]!.$jazz.id);
     expect(result?.image.isBinaryStreamEnded()).toBe(true);
     expect(result?.image.asBase64()).toStrictEqual(expect.any(String));
   });

package/src/media/utils.ts

@@ -6,7 +6,7 @@ export function highestResAvailable(
   wantedWidth: number,
   wantedHeight: number,
 ): { width: number; height: number; image: FileStream } | null {
-  const availableSizes: [number, number, string][] = image._raw
+  const availableSizes: [number, number, string][] = image.$jazz.raw
     .keys()
     .filter((key) => /^\d+x\d+$/.test(key))
     .map((key) => {
@@ -29,7 +29,9 @@ export function highestResAvailable(
       return {
         size,
         match: sizesMatchWanted(size[0], size[1], wantedWidth, wantedHeight),
-        isLoaded: isLoaded(image._raw.get(size[2]) as CoID<any> | undefined),
+        isLoaded: isLoaded(
+          image.$jazz.raw.get(size[2]) as CoID<any> | undefined,
+        ),
       };
     })
     .sort((a, b) => a.match - b.match);
@@ -102,7 +104,7 @@ function isLoaded(id: CoID<any> | null | undefined): boolean {
     return false;
   }
 
-  return !!Account.getMe()._raw.core.node.getLoaded(id);
+  return !!Account.getMe().$jazz.localNode.getLoaded(id);
 }
 
 export async function loadImage(
@@ -131,7 +133,7 @@ export async function loadImage(
     return null;
   }
 
-  const loadedOriginal = await FileStream.load(imageOrId.original.id);
+  const loadedOriginal = await FileStream.load(imageOrId.original.$jazz.id);
 
   if (!loadedOriginal) {
     console.warn("Unable to find the original image");
@@ -150,6 +152,7 @@ export async function loadImageBySize(
   wantedWidth: number,
   wantedHeight: number,
 ): Promise<{ width: number; height: number; image: FileStream } | null> {
+  // @ts-expect-error The resolved type for CoMap does not include catchall properties
   const image: ImageDefinition | null =
     typeof imageOrId === "string"
       ? await ImageDefinition.load(imageOrId)
@@ -163,7 +166,7 @@ export async function loadImageBySize(
     return loadImage(imageOrId);
   }
 
-  const availableSizes: [number, number, string][] = image._raw
+  const availableSizes: [number, number, string][] = image.$jazz.raw
     .keys()
     .filter((key) => /^\d+x\d+$/.test(key))
     .map((key) => {
@@ -189,7 +192,7 @@ export async function loadImageBySize(
   // image[bestTarget.size[2]] returns undefined if FileStream hasn't loaded yet.
   // Since we only need the file's ID to fetch it later, we check the raw _refs
   // which contain only the linked covalue's ID.
-  const file = image._refs[bestTarget.size[2]];
+  const file = image.$jazz.refs[bestTarget.size[2]];
 
   if (!file) {
     return null;

package/src/prosemirror/lib/plugin.ts

@@ -57,7 +57,7 @@ export function createJazzPlugin(
       setView(editorView);
 
       if (coRichText) {
-        coRichText.subscribe(handleCoRichTextChange);
+        coRichText.$jazz.subscribe(handleCoRichTextChange);
       }
 
       return {

package/src/prosemirror/lib/sync.ts

@@ -109,7 +109,7 @@ export function createSyncHandlers(coRichText: CoRichText | undefined) {
       const str = proseMirrorToHtml(tr.doc);
       localChange = true;
       try {
-        coRichText.applyDiff(str);
+        coRichText.$jazz.applyDiff(str);
       } finally {
         localChange = false;
       }

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

@@ -64,7 +64,7 @@ describe("createJazzPlugin", () => {
     const { coRichText, view } = await setupTest();
 
     // Update CoRichText content
-    coRichText.applyDiff("<p>Updated content</p>");
+    coRichText.$jazz.applyDiff("<p>Updated content</p>");
 
     // Wait for the next tick to allow the update to propagate
     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -135,7 +135,7 @@ describe("createJazzPlugin", () => {
     expect(view.state.selection.to).toBe(5);
 
     // Update CoRichText content
-    coRichText.applyDiff("<p>Hello world</p>");
+    coRichText.$jazz.applyDiff("<p>Hello world</p>");
 
     await new Promise((resolve) => setTimeout(resolve, 0));
 
@@ -153,7 +153,7 @@ describe("createJazzPlugin", () => {
     await new Promise((resolve) => setTimeout(resolve, 0));
 
     // Update CoRichText content
-    coRichText.applyDiff(
+    coRichText.$jazz.applyDiff(
       "<ol><li><p>A <strong>hu</strong><em><strong>man</strong></em>.</p></li></ol>",
     );
 
@@ -171,7 +171,7 @@ describe("createJazzPlugin", () => {
     );
 
     // Update CoRichText content
-    coRichText.applyDiff("<p>A human💪</p>");
+    coRichText.$jazz.applyDiff("<p>A human💪</p>");
 
     // Wait for the next tick to allow the update to propagate
     await new Promise((resolve) => setTimeout(resolve, 0));

package/src/react/media/image.tsx

@@ -149,7 +149,7 @@ export const Image = forwardRef<HTMLImageElement, ImageProps>(function Image(
     );
 
     if (!bestImage) return image.placeholderDataURL;
-    if (lastBestImage.current?.[0] === bestImage.image.id)
+    if (lastBestImage.current?.[0] === bestImage.image.$jazz.id)
       return lastBestImage.current?.[1];
 
     const blob = bestImage.image.toBlob();
@@ -157,7 +157,7 @@ export const Image = forwardRef<HTMLImageElement, ImageProps>(function Image(
     if (blob) {
       const url = URL.createObjectURL(blob);
       revokeObjectURL(lastBestImage.current?.[1]);
-      lastBestImage.current = [bestImage.image.id, url];
+      lastBestImage.current = [bestImage.image.$jazz.id, url];
       return url;
     }