@marimo-team/islands 0.19.5-dev25 → 0.19.5-dev29

package/src/core/network/requests-lazy.ts

@@ -50,6 +50,7 @@ const ACTIONS: Record<keyof AllRequests, Action> = {
   // Export operations start a connection
   exportAsHTML: "startConnection",
   exportAsMarkdown: "startConnection",
+  exportAsPDF: "startConnection",
   readCode: "startConnection",
   sendCopy: "throwError",
 

package/src/core/network/requests-network.ts

@@ -381,6 +381,15 @@ export function createNetworkRequests(): EditRequests & RunRequests {
         })
         .then(handleResponse);
     },
+    exportAsPDF: async (request) => {
+      return getClient()
+        .POST("/api/export/pdf", {
+          body: request,
+          parseAs: "blob",
+          params: getParams(),
+        })
+        .then(handleResponse);
+    },
     autoExportAsHTML: async (request) => {
       return getClient()
         .POST("/api/export/auto_export/html", {

package/src/core/network/requests-static.ts

@@ -76,6 +76,7 @@ export function createStaticRequests(): EditRequests & RunRequests {
     shutdownSession: throwNotInEditMode,
     exportAsHTML: throwNotInEditMode,
     exportAsMarkdown: throwNotInEditMode,
+    exportAsPDF: throwNotInEditMode,
     autoExportAsHTML: throwNotInEditMode,
     autoExportAsMarkdown: throwNotInEditMode,
     autoExportAsIPYNB: throwNotInEditMode,

package/src/core/network/requests-toasting.tsx

@@ -61,6 +61,7 @@ export function createErrorToastingRequests(
     shutdownSession: "Failed to shutdown session",
     exportAsHTML: "Failed to export HTML",
     exportAsMarkdown: "Failed to export Markdown",
+    exportAsPDF: "Failed to export PDF",
     autoExportAsHTML: "", // No toast
     autoExportAsMarkdown: "", // No toast
     autoExportAsIPYNB: "", // No toast

package/src/core/network/types.ts

@@ -21,6 +21,7 @@ export type ExportAsHTMLRequest = schemas["ExportAsHTMLRequest"];
 export type ExportAsMarkdownRequest = schemas["ExportAsMarkdownRequest"];
 export type ExportAsIPYNBRequest = schemas["ExportAsIPYNBRequest"];
 export type ExportAsScriptRequest = schemas["ExportAsScriptRequest"];
+export type ExportAsPDFRequest = schemas["ExportAsPDFRequest"];
 export type UpdateCellOutputsRequest = schemas["UpdateCellOutputsRequest"];
 export type FileCreateRequest = schemas["FileCreateRequest"];
 export type FileCreateResponse = schemas["FileCreateResponse"];
@@ -173,6 +174,7 @@ export interface EditRequests {
   // Export requests
   exportAsHTML: (request: ExportAsHTMLRequest) => Promise<string>;
   exportAsMarkdown: (request: ExportAsMarkdownRequest) => Promise<string>;
+  exportAsPDF: (request: ExportAsPDFRequest) => Promise<Blob>;
   autoExportAsHTML: (request: ExportAsHTMLRequest) => Promise<null>;
   autoExportAsMarkdown: (request: ExportAsMarkdownRequest) => Promise<null>;
   autoExportAsIPYNB: (request: ExportAsIPYNBRequest) => Promise<null>;

package/src/core/wasm/bridge.ts

@@ -586,6 +586,7 @@ export class PyodideBridge implements RunRequests, EditRequests {
   getWorkspaceFiles = throwNotImplemented;
   getRunningNotebooks = throwNotImplemented;
   shutdownSession = throwNotImplemented;
+  exportAsPDF = throwNotImplemented;
   autoExportAsHTML = throwNotImplemented;
   autoExportAsMarkdown = throwNotImplemented;
   autoExportAsIPYNB = throwNotImplemented;

package/src/utils/__tests__/download.test.tsx

@@ -0,0 +1,96 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { withLoadingToast } from "../download";
+
+// Mock the toast module
+const mockDismiss = vi.fn();
+vi.mock("@/components/ui/use-toast", () => ({
+  toast: vi.fn(() => ({
+    dismiss: mockDismiss,
+  })),
+}));
+
+// Mock the Spinner component
+vi.mock("@/components/icons/spinner", () => ({
+  Spinner: () => "MockSpinner",
+}));
+
+import { toast } from "@/components/ui/use-toast";
+
+describe("withLoadingToast", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should show a loading toast and dismiss on success", async () => {
+    const result = await withLoadingToast("Loading...", async () => {
+      return "success";
+    });
+
+    expect(toast).toHaveBeenCalledTimes(1);
+    expect(toast).toHaveBeenCalledWith({
+      title: "Loading...",
+    });
+    expect(mockDismiss).toHaveBeenCalledTimes(1);
+    expect(result).toBe("success");
+  });
+
+  it("should dismiss toast and rethrow on error", async () => {
+    const error = new Error("Operation failed");
+
+    await expect(
+      withLoadingToast("Loading...", async () => {
+        throw error;
+      }),
+    ).rejects.toThrow("Operation failed");
+
+    expect(toast).toHaveBeenCalledTimes(1);
+    expect(mockDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it("should return the value from the async function", async () => {
+    const expectedValue = { data: "test", count: 42 };
+
+    const result = await withLoadingToast("Processing...", async () => {
+      return expectedValue;
+    });
+
+    expect(result).toEqual(expectedValue);
+  });
+
+  it("should handle void functions", async () => {
+    let sideEffect = false;
+
+    await withLoadingToast("Saving...", async () => {
+      sideEffect = true;
+    });
+
+    expect(sideEffect).toBe(true);
+    expect(mockDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it("should use the provided title in the toast", async () => {
+    const customTitle = "Downloading PDF...";
+
+    await withLoadingToast(customTitle, async () => "done");
+
+    expect(toast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: customTitle,
+      }),
+    );
+  });
+
+  it("should wait for the async function to complete", async () => {
+    const events: string[] = [];
+
+    await withLoadingToast("Loading...", async () => {
+      events.push("start");
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      events.push("end");
+    });
+
+    expect(events).toEqual(["start", "end"]);
+    expect(mockDismiss).toHaveBeenCalledTimes(1);
+  });
+});

package/src/utils/download.ts

@@ -1,7 +1,31 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { toPng } from "html-to-image";
 import { toast } from "@/components/ui/use-toast";
+import { getRequestClient } from "@/core/network/requests";
 import { Filenames } from "@/utils/filenames";
+import { Paths } from "@/utils/paths";
+import { prettyError } from "./errors";
+
+/**
+ * Show a loading toast while an async operation is in progress.
+ * Automatically dismisses the toast when the operation completes or fails.
+ */
+export async function withLoadingToast<T>(
+  title: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const loadingToast = toast({
+    title,
+  });
+  try {
+    const result = await fn();
+    loadingToast.dismiss();
+    return result;
+  } catch (error) {
+    loadingToast.dismiss();
+    throw error;
+  }
+}
 
 export async function downloadHTMLAsImage(
   element: HTMLElement,
@@ -45,3 +69,33 @@ export function downloadBlob(blob: Blob, filename: string) {
   downloadByURL(url, filename);
   URL.revokeObjectURL(url);
 }
+
+/**
+ * Download the current notebook as a PDF file.
+ *
+ * WebPDF only requires Chromium to be installed.
+ * Standard PDF requires Pandoc & TeX (~few GBs) but is of higher quality.
+ */
+export async function downloadAsPDF(opts: {
+  filename: string;
+  webpdf: boolean;
+}) {
+  const client = getRequestClient();
+  const { filename, webpdf } = opts;
+
+  try {
+    const pdfBlob = await client.exportAsPDF({
+      webpdf,
+    });
+
+    const filenameWithoutPath = Paths.basename(filename);
+    downloadBlob(pdfBlob, Filenames.toPDF(filenameWithoutPath));
+  } catch (error) {
+    toast({
+      title: "Failed to download",
+      description: prettyError(error),
+      variant: "danger",
+    });
+    throw error;
+  }
+}

package/src/utils/filenames.ts

@@ -9,6 +9,9 @@ export const Filenames = {
   toPNG: (filename: string): string => {
     return Filenames.replace(filename, "png");
   },
+  toPDF: (filename: string): string => {
+    return Filenames.replace(filename, "pdf");
+  },
   toPY: (filename: string): string => {
     return Filenames.replace(filename, "py");
   },