jazz-tools 0.11.4 → 0.11.6

package/dist/coValues/extensions/imageDef.d.ts

@@ -9,6 +9,7 @@ export declare class ImageDefinition extends CoMap {
     [res: `${number}x${number}`]: co<FileStream | null>;
     highestResAvailable(options?: {
         maxWidth?: number;
+        targetWidth?: number;
     }): {
         res: `${number}x${number}`;
         stream: FileStream;

package/dist/coValues/extensions/imageDef.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imageDef.d.ts","sourceRoot":"","sources":["../../../src/coValues/extensions/imageDef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAuB,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,sBAAsB;AACtB,qBAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,uBAA+B;IAC3C,kBAAkB,CAAC,yBAAa;IAEhC,CAAC,EAAE,CAAC,KAAK,CAAC,wBAAsB;IAChC,CAAC,GAAG,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAEpD,mBAAmB,CAAC,OAAO,CAAC,EAAE;QAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG;QAAE,GAAG,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG,SAAS;CAyCnE"}
+{"version":3,"file":"imageDef.d.ts","sourceRoot":"","sources":["../../../src/coValues/extensions/imageDef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAuB,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,sBAAsB;AACtB,qBAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,uBAA+B;IAC3C,kBAAkB,CAAC,yBAAa;IAEhC,CAAC,EAAE,CAAC,KAAK,CAAC,wBAAsB;IAChC,CAAC,GAAG,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IAEpD,mBAAmB,CAAC,OAAO,CAAC,EAAE;QAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG;QAAE,GAAG,EAAE,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG,SAAS;CA+CnE"}

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-IOK4K3XC.js";
+} from "./chunk-2LO7CLFD.js";
 
 // src/index.ts
 import { MAX_RECOMMENDED_TX_SIZE, cojsonInternals } from "cojson";

package/dist/testing.js

@@ -5,7 +5,7 @@ import {
   createAnonymousJazzContext,
   createJazzContext,
   randomSessionProvider
-} from "./chunk-IOK4K3XC.js";
+} from "./chunk-2LO7CLFD.js";
 
 // src/testing.ts
 import { LocalNode } from "cojson";

package/dist/tests/imageDef.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=imageDef.test.d.ts.map

package/dist/tests/imageDef.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageDef.test.d.ts","sourceRoot":"","sources":["../../src/tests/imageDef.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -17,11 +17,11 @@
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.11.4",
+  "version": "0.11.6",
   "dependencies": {
     "@scure/bip39": "^1.3.0",
     "fast-myers-diff": "^3.2.0",
-    "cojson": "0.11.4"
+    "cojson": "0.11.6"
   },
   "devDependencies": {
     "tsup": "8.3.5",

package/src/coValues/extensions/imageDef.ts

@@ -12,6 +12,7 @@ export class ImageDefinition extends CoMap {
 
   highestResAvailable(options?: {
     maxWidth?: number;
+    targetWidth?: number;
   }): { res: `${number}x${number}`; stream: FileStream } | undefined {
     if (!subscriptionsScopes.get(this)) {
       console.warn(
@@ -19,33 +20,39 @@ export class ImageDefinition extends CoMap {
       );
     }
 
-    const resolutions = Object.keys(this).filter(
-      (key) =>
-        key.match(/^\d+x\d+$/) &&
-        (options?.maxWidth === undefined ||
-          Number(key.split("x")[0]) <= options.maxWidth),
+    const resolutions = Object.keys(this).filter((key) =>
+      key.match(/^\d+x\d+$/),
     ) as `${number}x${number}`[];
 
-    resolutions.sort((a, b) => {
+    let maxWidth = options?.maxWidth;
+
+    if (options?.targetWidth) {
+      const targetWidth = options.targetWidth;
+      const widths = resolutions.map((res) => Number(res.split("x")[0]));
+
+      maxWidth = Math.min(...widths.filter((w) => w >= targetWidth));
+    }
+
+    const validResolutions = resolutions.filter(
+      (key) => maxWidth === undefined || Number(key.split("x")[0]) <= maxWidth,
+    ) as `${number}x${number}`[];
+
+    // Sort the resolutions by width, smallest to largest
+    validResolutions.sort((a, b) => {
       const aWidth = Number(a.split("x")[0]);
       const bWidth = Number(b.split("x")[0]);
-      return aWidth - bWidth;
+      return aWidth - bWidth; // Sort smallest to largest
     });
 
     let highestAvailableResolution: `${number}x${number}` | undefined;
 
-    for (const resolution of resolutions) {
+    for (const resolution of validResolutions) {
       if (this[resolution] && this[resolution]?.getChunks()) {
         highestAvailableResolution = resolution;
-      } else {
-        return (
-          highestAvailableResolution && {
-            res: highestAvailableResolution,
-            stream: this[highestAvailableResolution]!,
-          }
-        );
       }
     }
+
+    // Return the highest complete resolution if we found one
     return (
       highestAvailableResolution && {
         res: highestAvailableResolution,

package/src/tests/coFeed.test.ts

@@ -470,6 +470,38 @@ describe("FileStream.loadAsBlob", async () => {
   });
 });
 
+describe("FileStream progress tracking", async () => {
+  test("createFromBlob should report upload progress correctly", async () => {
+    // Create 5MB test blob
+    const testData = new Uint8Array(5 * 1024 * 1024); // 5MB instead of 500KB
+    for (let i = 0; i < testData.length; i++) testData[i] = i % 256;
+    const testBlob = new Blob([testData]);
+
+    // Collect progress updates
+    const progressUpdates: number[] = [];
+    await FileStream.createFromBlob(testBlob, {
+      onProgress: (progress) => progressUpdates.push(progress),
+    });
+
+    // Verify progress reporting
+    expect(progressUpdates.length).toBeGreaterThan(1);
+
+    // Check values between 0-1, increasing, with final=1
+    progressUpdates.forEach((p) => {
+      expect(p).toBeGreaterThanOrEqual(0);
+      expect(p).toBeLessThanOrEqual(1);
+    });
+
+    for (let i = 1; i < progressUpdates.length; i++) {
+      expect(progressUpdates[i]!).toBeGreaterThanOrEqual(
+        progressUpdates[i - 1]!,
+      );
+    }
+
+    expect(progressUpdates[progressUpdates.length - 1]).toBe(1);
+  });
+});
+
 describe("waitForSync", async () => {
   test("CoFeed: should resolve when the value is uploaded", async () => {
     class TestStream extends CoFeed.Of(co.string) {}

package/src/tests/imageDef.test.ts

@@ -0,0 +1,269 @@
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
+import { describe, expect, test } from "vitest";
+import { Account, FileStream, ImageDefinition, co } from "../exports.js";
+
+const Crypto = await WasmCrypto.create();
+
+describe("ImageDefinition", async () => {
+  const me = await Account.create({
+    creationProps: { name: "Test User" },
+    crypto: Crypto,
+  });
+
+  test("Construction with basic properties", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+        placeholderDataURL: "data:image/jpeg;base64,...",
+      },
+      { owner: me },
+    );
+
+    expect(imageDef.originalSize).toEqual([1920, 1080]);
+    expect(imageDef.placeholderDataURL).toBe("data:image/jpeg;base64,...");
+  });
+
+  test("highestResAvailable with no resolutions", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const result = imageDef.highestResAvailable();
+    expect(result).toBeUndefined();
+  });
+
+  test("highestResAvailable with single resolution", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream = FileStream.create({ owner: me });
+    stream.start({ mimeType: "image/jpeg" });
+    stream.push(new Uint8Array([1, 2, 3]));
+    stream.end();
+
+    imageDef["1920x1080"] = stream;
+
+    const result = imageDef.highestResAvailable();
+    expect(result).toBeDefined();
+    expect(result?.res).toBe("1920x1080");
+    expect(result?.stream).toStrictEqual(stream);
+  });
+
+  test("highestResAvailable with multiple resolutions", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream1 = FileStream.create({ owner: me });
+    stream1.start({ mimeType: "image/jpeg" });
+    stream1.push(new Uint8Array([1, 2, 3]));
+    stream1.end();
+
+    const stream2 = FileStream.create({ owner: me });
+    stream2.start({ mimeType: "image/jpeg" });
+    stream2.push(new Uint8Array([4, 5, 6]));
+    stream2.end();
+
+    imageDef["1920x1080"] = stream1;
+    imageDef["1280x720"] = stream2;
+
+    const result = imageDef.highestResAvailable();
+    expect(result).toBeDefined();
+    expect(result?.res).toBe("1920x1080");
+    expect(result?.stream).toStrictEqual(stream1);
+  });
+
+  test("highestResAvailable with maxWidth option", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream1 = FileStream.create({ owner: me });
+    stream1.start({ mimeType: "image/jpeg" });
+    stream1.push(new Uint8Array([1, 2, 3]));
+    stream1.end();
+
+    const stream2 = FileStream.create({ owner: me });
+    stream2.start({ mimeType: "image/jpeg" });
+    stream2.push(new Uint8Array([4, 5, 6]));
+    stream2.end();
+
+    imageDef["1920x1080"] = stream1;
+    imageDef["1280x720"] = stream2;
+
+    const result = imageDef.highestResAvailable({ maxWidth: 1500 });
+    expect(result).toBeDefined();
+    expect(result?.res).toBe("1280x720");
+    expect(result?.stream).toStrictEqual(stream2);
+  });
+
+  test("highestResAvailable with missing chunks", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream1 = FileStream.create({ owner: me });
+    stream1.start({ mimeType: "image/jpeg" });
+    stream1.push(new Uint8Array([1, 2, 3]));
+    stream1.end();
+
+    const stream2 = FileStream.create({ owner: me });
+    stream2.start({ mimeType: "image/jpeg" });
+    // Don't end stream2, so it has no chunks
+
+    imageDef["1920x1080"] = stream1;
+    imageDef["1280x720"] = stream2;
+
+    const result = imageDef.highestResAvailable();
+    expect(result).toBeDefined();
+    expect(result?.res).toBe("1920x1080");
+    expect(result?.stream).toStrictEqual(stream1);
+  });
+
+  test("highestResAvailable with missing chunks in middle stream", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream1 = FileStream.create({ owner: me });
+    stream1.start({ mimeType: "image/jpeg" });
+    stream1.push(new Uint8Array([1, 2, 3]));
+    stream1.end();
+
+    const stream2 = FileStream.create({ owner: me });
+    stream2.start({ mimeType: "image/jpeg" });
+    // Don't end stream2, so it has no chunks
+
+    const stream3 = FileStream.create({ owner: me });
+    stream3.start({ mimeType: "image/jpeg" });
+    stream3.push(new Uint8Array([7, 8, 9]));
+    stream3.end();
+
+    imageDef["1920x1080"] = stream1;
+    imageDef["1280x720"] = stream2;
+    imageDef["1024x576"] = stream3;
+
+    const result = imageDef.highestResAvailable();
+    expect(result).toBeDefined();
+    expect(result?.res).toBe("1920x1080");
+    expect(result?.stream).toStrictEqual(stream1);
+  });
+
+  test("highestResAvailable with non-resolution keys", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream = FileStream.create({ owner: me });
+    stream.start({ mimeType: "image/jpeg" });
+    stream.push(new Uint8Array([1, 2, 3]));
+    stream.end();
+
+    // @ts-expect-error - Testing invalid key
+    imageDef["invalid-key"] = stream;
+
+    const result = imageDef.highestResAvailable();
+    expect(result).toBeUndefined();
+  });
+
+  test("highestResAvailable with targetWidth option", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream1 = FileStream.create({ owner: me });
+    stream1.start({ mimeType: "image/jpeg" });
+    stream1.push(new Uint8Array([1, 2, 3]));
+    stream1.end();
+
+    const stream2 = FileStream.create({ owner: me });
+    stream2.start({ mimeType: "image/jpeg" });
+    stream2.push(new Uint8Array([4, 5, 6]));
+    stream2.end();
+
+    const stream3 = FileStream.create({ owner: me });
+    stream3.start({ mimeType: "image/jpeg" });
+    stream3.push(new Uint8Array([7, 8, 9]));
+    stream3.end();
+
+    imageDef["1920x1080"] = stream1;
+    imageDef["1280x720"] = stream2;
+    imageDef["800x450"] = stream3;
+
+    // Should return 1280x720 as it's the smallest resolution >= 1000px
+    const result1 = imageDef.highestResAvailable({ targetWidth: 1000 });
+    expect(result1).toBeDefined();
+    expect(result1?.res).toBe("1280x720");
+    expect(result1?.stream).toStrictEqual(stream2);
+
+    // Should return 800x450 as it's the smallest resolution >= 700px
+    const result2 = imageDef.highestResAvailable({ targetWidth: 700 });
+    expect(result2).toBeDefined();
+    expect(result2?.res).toBe("800x450");
+    expect(result2?.stream).toStrictEqual(stream3);
+
+    // Should return 1920x1080 as it's the smallest resolution >= 1500px
+    const result3 = imageDef.highestResAvailable({ targetWidth: 1500 });
+    expect(result3).toBeDefined();
+    expect(result3?.res).toBe("1920x1080");
+    expect(result3?.stream).toStrictEqual(stream1);
+  });
+
+  test("highestResAvailable with targetWidth and incomplete streams", () => {
+    const imageDef = ImageDefinition.create(
+      {
+        originalSize: [1920, 1080],
+      },
+      { owner: me },
+    );
+
+    const stream1 = FileStream.create({ owner: me });
+    stream1.start({ mimeType: "image/jpeg" });
+    stream1.push(new Uint8Array([1, 2, 3]));
+    stream1.end();
+
+    const stream2 = FileStream.create({ owner: me });
+    stream2.start({ mimeType: "image/jpeg" });
+    // Don't end stream2, so it has no chunks
+
+    const stream3 = FileStream.create({ owner: me });
+    stream3.start({ mimeType: "image/jpeg" });
+    stream3.push(new Uint8Array([7, 8, 9]));
+    stream3.end();
+
+    imageDef["1920x1080"] = stream1;
+    imageDef["1280x720"] = stream2;
+    imageDef["800x450"] = stream3;
+
+    // Should skip 1280x720 as it's incomplete and return 1920x1080
+    const result = imageDef.highestResAvailable({ targetWidth: 1000 });
+    expect(result).toBeDefined();
+    expect(result?.res).toBe("800x450");
+    expect(result?.stream).toStrictEqual(stream1);
+  });
+});