jazz-tools 0.16.6 → 0.17.0

package/src/react-native-media-images/index.ts

@@ -1,238 +0,0 @@
-import ImageResizer from "@bam.tech/react-native-image-resizer";
-import * as FileSystem from "expo-file-system";
-import {
-  Account,
-  FileStream,
-  Group,
-  ImageDefinition,
-  Loaded,
-} from "jazz-tools";
-import { Image } from "react-native";
-
-function arrayBuffer(blob: Blob): Promise<ArrayBuffer> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onloadend = () => {
-      resolve(reader.result as ArrayBuffer);
-    };
-    reader.onerror = (error) => {
-      reject(error);
-    };
-    reader.readAsArrayBuffer(blob);
-  });
-}
-
-async function fileUriToBlob(uri: string): Promise<Blob> {
-  try {
-    const response = await fetch(uri);
-    const blob = await response.blob();
-    blob.arrayBuffer = () => arrayBuffer(blob);
-    return blob;
-  } catch (error) {
-    console.error("Failed to convert file URI to Blob:", error);
-    throw new Error("Failed to convert file URI to Blob");
-  }
-}
-
-async function convertFileContentsToBase64DataURI(
-  fileUri: string,
-  contentType: string,
-) {
-  try {
-    const base64 = await FileSystem.readAsStringAsync(fileUri, {
-      encoding: FileSystem.EncodingType.Base64,
-    });
-    return `data:${contentType};base64,${base64}`;
-  } catch (error) {
-    console.error("Failed to convert file to base64:", error);
-    return null;
-  }
-}
-
-function base64DataURIToParts(base64Data: string) {
-  const parts = base64Data.split(",");
-  const contentType = parts[0]?.split(":")?.[1]?.split(";")?.[0] || "";
-  const data = parts[1] || "";
-  return { contentType, data };
-}
-
-function contentTypeToFormat(contentType: string) {
-  if (contentType.includes("image/png")) return "PNG";
-  if (contentType.includes("image/jpeg")) return "JPEG";
-  if (contentType.includes("image/webp")) return "WEBP";
-  return "PNG";
-}
-
-async function base64DataURIToBlob(base64Data: string) {
-  const { contentType, data } = base64DataURIToParts(base64Data);
-  const byteCharacters = atob(data);
-
-  const byteNumbers = new Array(byteCharacters.length);
-  for (let i = 0; i < byteCharacters.length; i++) {
-    byteNumbers[i] = byteCharacters.charCodeAt(i);
-  }
-  const byteArray = new Uint8Array(byteNumbers);
-
-  // @ts-expect-error byteArray has data
-  const blob = new Blob(byteArray, { type: contentType });
-  blob.arrayBuffer = () => arrayBuffer(blob);
-  return blob;
-}
-
-async function getImageDimensions(
-  uri: string,
-): Promise<{ width: number; height: number }> {
-  return new Promise((resolve, reject) => {
-    Image.getSize(
-      uri,
-      (width, height) => resolve({ width, height }),
-      (error) => {
-        console.error("Failed to get image dimensions:", error);
-        reject(new Error("Failed to get image dimensions"));
-      },
-    );
-  });
-}
-
-/** @category Image creation */
-export async function createImageNative(
-  base64ImageDataURI: string,
-  options: {
-    owner?: Group | Account;
-    maxSize?: 256 | 1024 | 2048;
-  } = {},
-): Promise<Loaded<typeof ImageDefinition>> {
-  try {
-    const { contentType } = base64DataURIToParts(base64ImageDataURI);
-    const format = contentTypeToFormat(contentType);
-
-    let originalWidth, originalHeight;
-    try {
-      ({ width: originalWidth, height: originalHeight } =
-        await getImageDimensions(base64ImageDataURI));
-    } catch (error) {
-      console.error("Error getting image dimensions:", error);
-      throw new Error("Failed to get image dimensions");
-    }
-
-    let placeholderImage;
-    try {
-      placeholderImage = await ImageResizer.createResizedImage(
-        base64ImageDataURI,
-        8,
-        8,
-        format,
-        100,
-        0,
-      );
-    } catch (error) {
-      console.error("Error creating placeholder image:", error);
-      throw new Error("Failed to create placeholder image");
-    }
-
-    const placeholderDataURL = await convertFileContentsToBase64DataURI(
-      placeholderImage.uri,
-      contentType,
-    );
-
-    if (!placeholderDataURL) {
-      throw new Error("Failed to create placeholder data URL");
-    }
-
-    const imageDefinition = ImageDefinition.create(
-      {
-        originalSize: [originalWidth, originalHeight],
-        placeholderDataURL,
-      },
-      options.owner,
-    );
-
-    const addImageStream = async (
-      width: number,
-      height: number,
-      label: string,
-    ) => {
-      try {
-        const resizedImage = await ImageResizer.createResizedImage(
-          base64ImageDataURI,
-          width,
-          height,
-          format,
-          80,
-          0,
-        );
-
-        const binaryStream = await FileStream.createFromBlob(
-          await fileUriToBlob(resizedImage.uri),
-          imageDefinition._owner,
-        );
-
-        imageDefinition[label] = binaryStream;
-      } catch (error) {
-        console.error(`Error adding image stream for ${label}:`, error);
-        throw new Error(`Failed to add image stream for ${label}`);
-      }
-    };
-
-    if (originalWidth > 256 || originalHeight > 256) {
-      const width =
-        originalWidth > originalHeight
-          ? 256
-          : Math.round(256 * (originalWidth / originalHeight));
-      const height =
-        originalHeight > originalWidth
-          ? 256
-          : Math.round(256 * (originalHeight / originalWidth));
-      await addImageStream(width, height, `${width}x${height}`);
-    }
-
-    if (options.maxSize === 256) return imageDefinition;
-
-    if (originalWidth > 1024 || originalHeight > 1024) {
-      const width =
-        originalWidth > originalHeight
-          ? 1024
-          : Math.round(1024 * (originalWidth / originalHeight));
-      const height =
-        originalHeight > originalWidth
-          ? 1024
-          : Math.round(1024 * (originalHeight / originalWidth));
-      await addImageStream(width, height, `${width}x${height}`);
-    }
-
-    if (options.maxSize === 1024) return imageDefinition;
-
-    if (originalWidth > 2048 || originalHeight > 2048) {
-      const width =
-        originalWidth > originalHeight
-          ? 2048
-          : Math.round(2048 * (originalWidth / originalHeight));
-      const height =
-        originalHeight > originalWidth
-          ? 2048
-          : Math.round(2048 * (originalHeight / originalWidth));
-      await addImageStream(width, height, `${width}x${height}`);
-    }
-
-    if (options.maxSize === 2048) return imageDefinition;
-
-    if (options.maxSize === undefined || options.maxSize > 2048) {
-      try {
-        const originalBinaryStream = await FileStream.createFromBlob(
-          await base64DataURIToBlob(base64ImageDataURI),
-          imageDefinition._owner,
-        );
-        imageDefinition[`${originalWidth}x${originalHeight}`] =
-          originalBinaryStream;
-      } catch (error) {
-        console.error("Error adding original image stream:", error);
-        throw new Error("Failed to add original image stream");
-      }
-    }
-
-    return imageDefinition;
-  } catch (error) {
-    console.error("Error in createImage:", error);
-    throw error;
-  }
-}

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

@@ -1,278 +0,0 @@
-import { WasmCrypto } from "cojson/crypto/WasmCrypto";
-import { describe, expect, test } from "vitest";
-import { Account, FileStream, ImageDefinition } 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 = ImageDefinition.highestResAvailable(imageDef);
-    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 = ImageDefinition.highestResAvailable(imageDef);
-    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 = ImageDefinition.highestResAvailable(imageDef);
-    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 = ImageDefinition.highestResAvailable(imageDef, {
-      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 = ImageDefinition.highestResAvailable(imageDef);
-    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 = ImageDefinition.highestResAvailable(imageDef);
-    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();
-
-    imageDef["invalid-key"] = stream;
-
-    const result = ImageDefinition.highestResAvailable(imageDef);
-    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 = ImageDefinition.highestResAvailable(imageDef, {
-      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 = ImageDefinition.highestResAvailable(imageDef, {
-      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 = ImageDefinition.highestResAvailable(imageDef, {
-      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 = ImageDefinition.highestResAvailable(imageDef, {
-      targetWidth: 1000,
-    });
-    expect(result).toBeDefined();
-    expect(result?.res).toBe("800x450");
-    expect(result?.stream).toStrictEqual(stream1);
-  });
-});