jazz-tools 0.16.5 → 0.17.0

package/.svelte-kit/__package__/index.d.ts

@@ -3,4 +3,5 @@ export * from "./auth/index.js";
 export * from "./jazz.svelte.js";
 export * from "./jazz.class.svelte.js";
 export { useIsAuthenticated } from "./auth/useIsAuthenticated.svelte.js";
+export * from "./media/index.js";
 //# sourceMappingURL=index.d.ts.map

package/.svelte-kit/__package__/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACvE,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/svelte/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACvE,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,cAAc,kBAAkB,CAAC"}

package/.svelte-kit/__package__/index.js

@@ -3,3 +3,4 @@ export * from "./auth/index.js";
 export * from "./jazz.svelte.js";
 export * from "./jazz.class.svelte.js";
 export { useIsAuthenticated } from "./auth/useIsAuthenticated.svelte.js";
+export * from "./media/index.js";

package/.svelte-kit/__package__/media/image.svelte

@@ -0,0 +1,131 @@
+<script lang="ts">
+import { ImageDefinition } from "jazz-tools";
+import { highestResAvailable } from "jazz-tools/media";
+import { onDestroy } from "svelte";
+import type { HTMLImgAttributes } from "svelte/elements";
+import { CoState } from "../jazz.class.svelte";
+
+interface ImageProps extends Omit<HTMLImgAttributes, "width" | "height"> {
+  imageId: string;
+  width?: number | "original";
+  height?: number | "original";
+}
+
+const { imageId, width, height, ...rest }: ImageProps = $props();
+
+const imageState = new CoState(ImageDefinition, imageId);
+let lastBestImage: [string, string] | null = null;
+
+/**
+ * For lazy loading, we use the browser's strategy for images with loading="lazy".
+ * We use an empty image, and when the browser triggers the load event, we load the best available image.
+ * On page loading, if the image url is already in browser's cache, the load event is triggered immediately.
+ * This is why we need to use a different blob url for every image.
+ */
+let waitingLazyLoading = $state(rest.loading === "lazy");
+const lazyPlaceholder = $derived.by(() =>
+  waitingLazyLoading ? URL.createObjectURL(emptyPixelBlob) : undefined,
+);
+
+const dimensions = $derived.by<{
+  width: number | undefined;
+  height: number | undefined;
+}>(() => {
+  const originalWidth = imageState.current?.originalSize?.[0];
+  const originalHeight = imageState.current?.originalSize?.[1];
+
+  // Both width and height are "original"
+  if (width === "original" && height === "original") {
+    return { width: originalWidth, height: originalHeight };
+  }
+
+  // Width is "original", height is a number
+  if (width === "original" && typeof height === "number") {
+    if (originalWidth && originalHeight) {
+      return {
+        width: Math.round((height * originalWidth) / originalHeight),
+        height,
+      };
+    }
+    return { width: undefined, height };
+  }
+
+  // Height is "original", width is a number
+  if (height === "original" && typeof width === "number") {
+    if (originalWidth && originalHeight) {
+      return {
+        width,
+        height: Math.round((width * originalHeight) / originalWidth),
+      };
+    }
+    return { width, height: undefined };
+  }
+
+  // In all other cases, use the property value:
+  return {
+    width: width === "original" ? originalWidth : width,
+    height: height === "original" ? originalHeight : height,
+  };
+});
+
+const src = $derived.by(() => {
+  if (waitingLazyLoading) {
+    return lazyPlaceholder;
+  }
+
+  const image = imageState.current;
+  if (!image) return undefined;
+
+  const bestImage = highestResAvailable(
+    image,
+    dimensions.width || dimensions.height || 9999,
+    dimensions.height || dimensions.width || 9999,
+  );
+
+  if (!bestImage) return image.placeholderDataURL;
+  if (lastBestImage?.[0] === bestImage.image.id) return lastBestImage?.[1];
+
+  const blob = bestImage.image.toBlob();
+
+  if (blob) {
+    const url = URL.createObjectURL(blob);
+    revokeObjectURL(lastBestImage?.[1]);
+    lastBestImage = [bestImage.image.id, url];
+    return url;
+  }
+
+  return image.placeholderDataURL;
+});
+
+// Cleanup object URL on component destroy
+onDestroy(() => {
+  revokeObjectURL(lastBestImage?.[1]);
+});
+
+function revokeObjectURL(url: string | undefined) {
+  if (url && url.startsWith("blob:")) {
+    URL.revokeObjectURL(url);
+  }
+}
+
+const emptyPixelBlob = new Blob(
+  [
+    Uint8Array.from(
+      atob(
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
+      ),
+      (c) => c.charCodeAt(0),
+    ),
+  ],
+  { type: "image/png" },
+);
+</script>
+
+<img
+  {src}
+  width={dimensions.width}
+  height={dimensions.height}
+  alt={rest.alt}
+  onload={() => {waitingLazyLoading = false}}
+  {...rest}
+/>

package/.svelte-kit/__package__/media/image.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLImgAttributes } from "svelte/elements";
+interface ImageProps extends Omit<HTMLImgAttributes, "width" | "height"> {
+    imageId: string;
+    width?: number | "original";
+    height?: number | "original";
+}
+declare const Image: import("svelte").Component<ImageProps, {}, "">;
+type Image = ReturnType<typeof Image>;
+export default Image;
+//# sourceMappingURL=image.svelte.d.ts.map

package/.svelte-kit/__package__/media/image.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.svelte.d.ts","sourceRoot":"","sources":["../../../../src/svelte/media/image.svelte.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD,UAAU,UAAW,SAAQ,IAAI,CAAC,iBAAiB,EAAE,OAAO,GAAG,QAAQ,CAAC;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;CAC9B;AA2HD,QAAA,MAAM,KAAK,gDAAsC,CAAC;AAClD,KAAK,KAAK,GAAG,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC;AACtC,eAAe,KAAK,CAAC"}

package/.svelte-kit/__package__/media/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Image } from "./image.svelte";
+//# sourceMappingURL=index.d.ts.map

package/.svelte-kit/__package__/media/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/svelte/media/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,gBAAgB,CAAC"}

package/.svelte-kit/__package__/media/index.js

@@ -0,0 +1 @@
+export { default as Image } from "./image.svelte";

package/.svelte-kit/__package__/tests/media/image.svelte.test.d.ts

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

package/.svelte-kit/__package__/tests/media/image.svelte.test.d.ts.map

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

package/.svelte-kit/__package__/tests/media/image.svelte.test.js

@@ -0,0 +1,430 @@
+// @vitest-environment happy-dom
+import { FileStream, ImageDefinition } from "jazz-tools";
+import { createJazzTestAccount } from "jazz-tools/testing";
+import { describe, expect, it, vi } from "vitest";
+import Image from "../../media/image.svelte";
+import { render, screen, waitFor } from "../testUtils";
+describe("Image", async () => {
+    const account = await createJazzTestAccount({
+        isCurrentActiveAccount: true,
+    });
+    const renderWithAccount = (props) => render(Image, props, { account });
+    describe("initial rendering", () => {
+        it("should render nothing if coValue is not found", async () => {
+            const { container } = renderWithAccount({
+                imageId: "co_zMTubMby3QiKDYnW9e2BEXW7Xaq",
+                alt: "test",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBe(null);
+            expect(img.getAttribute("height")).toBe(null);
+            expect(img.alt).toBe("test");
+            expect(img.src).toBe("");
+        });
+        it("should render an empty image if the image is not loaded yet", async () => {
+            const original = FileStream.create({ owner: account._owner });
+            original.start({ mimeType: "image/jpeg" });
+            // Don't end original, so it has no chunks
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBe(null);
+            expect(img.getAttribute("height")).toBe(null);
+            expect(img.alt).toBe("test");
+            expect(img.src).toBe("");
+        });
+        it("should render the placeholder image if the image is not loaded yet", async () => {
+            const placeholderDataUrl = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=";
+            const original = FileStream.create({ owner: account._owner });
+            original.start({ mimeType: "image/jpeg" });
+            // Don't end original, so it has no chunks
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [100, 100],
+                progressive: false,
+                placeholderDataURL: placeholderDataUrl,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.src).toBe(placeholderDataUrl);
+        });
+        it("should render the original image once loaded", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            renderWithAccount({
+                imageId: im.id,
+                alt: "test-loading",
+            });
+            await waitFor(() => {
+                expect(screen.getByAltText("test-loading").src).toBe("blob:test-100");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledOnce();
+        });
+    });
+    describe("dimensions", () => {
+        it("should render the original image if the width and height are not set", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBe(null);
+            expect(img.getAttribute("height")).toBe(null);
+        });
+        it("should render the original sizes", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                width: "original",
+                height: "original",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBe("100");
+            expect(img.getAttribute("height")).toBe("100");
+        });
+        it("should render the original size keeping the aspect ratio", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                width: "original",
+                height: 300,
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBe("300");
+            expect(img.getAttribute("height")).toBe("300");
+        });
+        it("should render the width attribute if it is set", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                width: 50,
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBe("50");
+            expect(img.getAttribute("height")).toBeNull();
+        });
+        it("should render the height attribute if it is set", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                height: 50,
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.getAttribute("width")).toBeNull();
+            expect(img.getAttribute("height")).toBe("50");
+        });
+        it("should render the class attribute if it is set", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                class: "test-class",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.classList.contains("test-class")).toBe(true);
+        });
+    });
+    describe("progressive loading", () => {
+        it("should render the resized image if progressive loading is enabled", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const original = await createDummyFileStream(500, account);
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [500, 500],
+                progressive: true,
+            }, {
+                owner: account,
+            });
+            im["500x500"] = original;
+            im["256x256"] = await createDummyFileStream(256, account);
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test-progressive",
+                width: 300,
+            });
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-500");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledOnce();
+        });
+        it("should show the highest resolution images as they are loaded", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const original = await createDummyFileStream(1920, account);
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [1920, 1080],
+                progressive: true,
+            }, {
+                owner: account,
+            });
+            im["1920x1080"] = original;
+            im["256x256"] = await createDummyFileStream(256, account);
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test-progressive",
+                width: 1024,
+            });
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-1920");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(1);
+            // Load higher resolution image
+            im["1024x1024"] = await createDummyFileStream(1024, account);
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-1024");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(2);
+        });
+        it("should show the best loaded resolution if width is set", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const original = await FileStream.createFromBlob(createDummyBlob(1), {
+                owner: account,
+            });
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [100, 100],
+                progressive: true,
+            }, {
+                owner: account,
+            });
+            im["100x100"] = original;
+            im["256x256"] = await createDummyFileStream(256, account);
+            im["1024x1024"] = await createDummyFileStream(1024, account);
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test-progressive",
+                width: 256,
+            });
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-256");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(1);
+        });
+        it("should show the original image if asked resolution matches", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const original = await createDummyFileStream(100, account);
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [100, 100],
+                progressive: true,
+            }, {
+                owner: account,
+            });
+            im["100x100"] = original;
+            im["256x256"] = await createDummyFileStream(256, account);
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test-progressive",
+                width: 100,
+            });
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-100");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(1);
+        });
+        it("should update to a higher resolution image when width/height props are changed at runtime", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const original = await createDummyFileStream(256, account);
+            const im = ImageDefinition.create({
+                original,
+                originalSize: [256, 256],
+                progressive: true,
+            }, {
+                owner: account,
+            });
+            im["256x256"] = original;
+            im["1024x1024"] = await createDummyFileStream(1024, account);
+            const { container, rerender } = renderWithAccount({
+                imageId: im.id,
+                alt: "test-dynamic",
+                width: 256,
+                height: 256,
+            });
+            // Initially, should load 256x256
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-256");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(1);
+            rerender({
+                imageId: im.id,
+                alt: "test-dynamic",
+                width: 1024,
+                height: 1024,
+            });
+            // After prop change, should load 1024x1024
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-1024");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("lazy loading", () => {
+        it("should return an empty png if loading is lazy and placeholder is not set", async () => {
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                loading: "lazy",
+            });
+            const img = container.querySelector("img");
+            expect(img).toBeDefined();
+            expect(img.src).toBe("blob:test-70");
+        });
+        it("should load the image when threshold is reached", async () => {
+            const createObjectURLSpy = vi
+                .spyOn(URL, "createObjectURL")
+                .mockImplementation((blob) => {
+                if (!(blob instanceof Blob)) {
+                    throw new Error("Blob expected");
+                }
+                return `blob:test-${blob.size}`;
+            });
+            const im = ImageDefinition.create({
+                original: await createDummyFileStream(100, account),
+                originalSize: [100, 100],
+                progressive: false,
+            }, {
+                owner: account,
+            });
+            const { container } = renderWithAccount({
+                imageId: im.id,
+                alt: "test",
+                loading: "lazy",
+            });
+            const img = container.querySelector("img");
+            // simulate the load event when the browser's viewport reach the image
+            img.dispatchEvent(new Event("load"));
+            await waitFor(() => {
+                expect(container.querySelector("img").src).toBe("blob:test-100");
+            });
+            expect(createObjectURLSpy).toHaveBeenCalledTimes(2);
+        });
+    });
+});
+function createDummyBlob(size) {
+    const blob = new Blob([new Uint8Array(size)], { type: "image/png" });
+    return blob;
+}
+function createDummyFileStream(size, account) {
+    return FileStream.createFromBlob(createDummyBlob(size), {
+        owner: account,
+    });
+}

package/.svelte-kit/__package__/tests/testUtils.d.ts

@@ -0,0 +1,11 @@
+import { Account, AnonymousJazzAgent } from "jazz-tools";
+import { Component, ComponentProps } from "svelte";
+type JazzExtendedOptions = {
+    account: Account | {
+        guest: AnonymousJazzAgent;
+    };
+};
+declare const render: <T extends Component>(component: T, props: ComponentProps<T>, jazzOptions: JazzExtendedOptions) => import("@testing-library/svelte").RenderResult<T, typeof import("@testing-library/dom/types/queries")>;
+export * from "@testing-library/svelte";
+export { render };
+//# sourceMappingURL=testUtils.d.ts.map

package/.svelte-kit/__package__/tests/testUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../../../src/svelte/tests/testUtils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAGnD,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,OAAO,GAAG;QAAE,KAAK,EAAE,kBAAkB,CAAA;KAAE,CAAC;CAClD,CAAC;AAEF,QAAA,MAAM,MAAM,GAAI,CAAC,SAAS,SAAS,aACtB,CAAC,SACL,cAAc,CAAC,CAAC,CAAC,eACX,mBAAmB,2GAejC,CAAC;AAEF,cAAc,yBAAyB,CAAC;AAExC,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/.svelte-kit/__package__/tests/testUtils.js

@@ -0,0 +1,17 @@
+import { render as renderSvelte } from "@testing-library/svelte";
+import { TestJazzContextManager } from "jazz-tools/testing";
+import { JAZZ_AUTH_CTX, JAZZ_CTX } from "../jazz.svelte";
+const render = (component, props, jazzOptions) => {
+    const ctx = TestJazzContextManager.fromAccountOrGuest(jazzOptions.account);
+    return renderSvelte(
+    // @ts-expect-error Svelte new Component type is not compatible with @testing-library/svelte
+    component, {
+        props,
+        context: new Map([
+            [JAZZ_CTX, { current: ctx.getCurrentValue() }],
+            [JAZZ_AUTH_CTX, ctx.getAuthSecretStorage()],
+        ]),
+    });
+};
+export * from "@testing-library/svelte";
+export { render };

package/.svelte-kit/__package__/tests/types.d.ts

@@ -0,0 +1,3 @@
+declare module "*.svelte" {
+  export { SvelteComponentDev as default } from "svelte/internal";
+}