@marimo-team/frontend 0.14.18-dev36 → 0.14.18-dev38

package/src/core/static/__tests__/files.test.ts

@@ -4,6 +4,7 @@
 import http from "node:http";
 import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import { createLoader } from "@/plugins/impl/vega/vega-loader";
+import { Functions } from "@/utils/functions";
 import type { DataURLString } from "@/utils/json/base64";
 import { patchFetch, patchVegaLoader } from "../files";
 
@@ -83,6 +84,104 @@ describe("patchFetch", () => {
       expect(text).toBe("hello,world\n");
     }
   });
+
+  it("should handle file:// URLs with @file/ paths", async () => {
+    const virtualFiles = {
+      "/@file/local-data.txt":
+        "data:text/plain;base64,TG9jYWwgZmlsZSBkYXRh" as DataURLString,
+    };
+
+    const unpatch = patchFetch(virtualFiles);
+
+    const response = await window.fetch(
+      "file:///Users/test/@file/local-data.txt",
+    );
+    const text = await response.text();
+
+    expect(text).toBe("Local file data");
+    expect(response.headers.get("Content-Type")).toBe("text/plain");
+
+    unpatch();
+  });
+
+  it("should handle blob: base URIs correctly", async () => {
+    // Mock document.baseURI to simulate blob: protocol
+    const originalBaseURI = document.baseURI;
+    Object.defineProperty(document, "baseURI", {
+      value: "blob:https://example.com/uuid",
+      configurable: true,
+    });
+
+    const virtualFiles = {
+      "/@file/blob-test.json":
+        "data:application/json;base64,eyJ0ZXN0IjogdHJ1ZX0=" as DataURLString,
+    };
+
+    patchFetch(virtualFiles);
+
+    const response = await window.fetch("/@file/blob-test.json");
+    const text = await response.text();
+
+    expect(text).toBe('{"test": true}');
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+
+    // Restore original baseURI
+    Object.defineProperty(document, "baseURI", {
+      value: originalBaseURI,
+      configurable: true,
+    });
+  });
+
+  it("should handle various content types", async () => {
+    const virtualFiles = {
+      "/@file/test.csv": "data:text/csv;base64,YSxiLGMK" as DataURLString,
+      "/@file/test.json": "data:application/json;base64,e30K" as DataURLString,
+      "/@file/test.txt": "data:text/plain;base64,dGVzdA==" as DataURLString,
+      "/@file/test.bin":
+        "data:application/octet-stream;base64,AAECAwQ=" as DataURLString,
+    };
+
+    patchFetch(virtualFiles);
+
+    const testCases = [
+      { file: "/@file/test.csv", expectedType: "text/csv" },
+      { file: "/@file/test.json", expectedType: "application/json" },
+      { file: "/@file/test.txt", expectedType: "text/plain" },
+      { file: "/@file/test.bin", expectedType: "application/octet-stream" },
+    ];
+
+    for (const { file, expectedType } of testCases) {
+      const response = await window.fetch(file);
+      expect(response.headers.get("Content-Type")).toBe(expectedType);
+    }
+  });
+
+  it("should handle data: URLs directly without processing", async () => {
+    const virtualFiles = {};
+    patchFetch(virtualFiles);
+
+    const dataUrl = "data:text/plain;base64,SGVsbG8gV29ybGQ=";
+    const response = await window.fetch(dataUrl);
+    const text = await response.text();
+
+    expect(text).toBe("Hello World");
+  });
+
+  it("should handle error cases gracefully", async () => {
+    const virtualFiles = {};
+    const unpatch = patchFetch(virtualFiles);
+
+    // Mock Logger.error to avoid console output during tests
+    const loggerSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(Functions.NOOP);
+
+    // This should fallback to original fetch and potentially fail
+    await expect(window.fetch("invalid://url")).rejects.toThrow();
+
+    unpatch();
+    loggerSpy.mockRestore();
+  });
 });
 
 describe("patchVegaLoader - loader.http", () => {
@@ -180,4 +279,216 @@ describe("patchVegaLoader - loader.load", () => {
     await expect(loader.load("/non-existent-file.json")).rejects.toThrow();
     unpatch();
   });
+
+  it("should handle file:// URLs with @file/ paths in loader.load", async () => {
+    const virtualFiles = {
+      "/@file/vega-data.json":
+        "data:application/json;base64,eyJ2YWx1ZXMiOiBbMSwgMiwgM119" as DataURLString,
+    };
+
+    const loader = createLoader();
+    const unpatch = patchVegaLoader(loader, virtualFiles);
+
+    try {
+      const content = await loader.load("file:///path/to/@file/vega-data.json");
+      expect(content).toBe('{"values": [1, 2, 3]}');
+    } catch (error) {
+      // If it falls back to original loader and fails, that's expected for file:// URLs
+      // The important thing is that the virtual file lookup was attempted
+      expect(error).toBeDefined();
+    }
+
+    unpatch();
+  });
+
+  it("should pass files parameter correctly to maybeGetVirtualFile in loader.load", async () => {
+    // This test ensures the bug fix where files parameter was missing
+    const virtualFiles = {
+      "/test-file.json":
+        "data:application/json;base64,eyJmaXhlZCI6IHRydWV9" as DataURLString,
+    };
+
+    const loader = createLoader();
+    const unpatch = patchVegaLoader(loader, virtualFiles);
+    const content = await loader.load("/test-file.json");
+    unpatch();
+
+    expect(content).toBe('{"fixed": true}');
+  });
+
+  it("should handle different URL patterns in loader.load", async () => {
+    const virtualFiles = {
+      "/@file/pattern-test.json":
+        "data:application/json;base64,eyJwYXR0ZXJuIjogInRlc3QifQ==" as DataURLString,
+    };
+
+    const loader = createLoader();
+    const unpatch = patchVegaLoader(loader, virtualFiles);
+
+    // Test URL patterns that should resolve to the same virtual file
+    const testUrls = [
+      "/@file/pattern-test.json",
+      "./@file/pattern-test.json",
+      "http://example.com/@file/pattern-test.json",
+    ];
+
+    for (const url of testUrls) {
+      const content = await loader.load(url);
+      expect(content).toBe('{"pattern": "test"}');
+    }
+
+    // Test file:// URL separately since it might fallback
+    try {
+      const content = await loader.load(
+        "file:///local/path/@file/pattern-test.json",
+      );
+      expect(content).toBe('{"pattern": "test"}');
+    } catch (error) {
+      // Expected if it falls back to original loader
+      expect(error).toBeDefined();
+    }
+
+    unpatch();
+  });
+});
+
+describe("maybeGetVirtualFile utility function", () => {
+  it("should handle URLs without leading dots correctly", async () => {
+    const virtualFiles = {
+      "/file.txt": "data:text/plain;base64,dGVzdA==" as DataURLString,
+      "file.txt": "data:text/plain;base64,dGVzdA==" as DataURLString,
+    };
+
+    patchFetch(virtualFiles);
+
+    // Both should work
+    const response1 = await window.fetch("./file.txt");
+    const response2 = await window.fetch("/file.txt");
+
+    const text1 = await response1.text();
+    const text2 = await response2.text();
+
+    expect(text1).toBe("test");
+    expect(text2).toBe("test");
+  });
+
+  it("should handle complex file:// URLs with nested paths", async () => {
+    const virtualFiles = {
+      "/@file/nested/data.json":
+        "data:application/json;base64,eyJuZXN0ZWQiOiB0cnVlfQ==" as DataURLString,
+    };
+
+    const unpatch = patchFetch(virtualFiles);
+
+    const response = await window.fetch(
+      "file:///Users/project/deep/path/@file/nested/data.json",
+    );
+    const text = await response.text();
+
+    expect(text).toBe('{"nested": true}');
+
+    unpatch();
+  });
+
+  it("should handle URLs when @file/ is not found in file:// URLs", async () => {
+    const virtualFiles = {
+      "/@file/test.txt": "data:text/plain;base64,dGVzdA==" as DataURLString,
+    };
+
+    const unpatch = patchFetch(virtualFiles);
+
+    // This file:// URL doesn't contain @file/, so it should fallback to original fetch
+    await expect(
+      window.fetch("file:///simple/path/test.txt"),
+    ).rejects.toThrow();
+
+    unpatch();
+  });
+});
+
+describe("error handling and edge cases", () => {
+  it("should restore original functions after unpatch", async () => {
+    const originalFetch = window.fetch;
+    const loader = createLoader();
+
+    const unpatchFetch = patchFetch({});
+    const unpatchLoader = patchVegaLoader(loader, {});
+
+    // Functions should be patched
+    expect(window.fetch).not.toBe(originalFetch);
+
+    // Test that the patched functions work
+    const virtualFiles = {
+      "/@file/test.txt": "data:text/plain;base64,dGVzdA==" as DataURLString,
+    };
+
+    // Re-patch with test data
+    unpatchFetch();
+    unpatchLoader();
+
+    const unpatchFetch2 = patchFetch(virtualFiles);
+    const unpatchLoader2 = patchVegaLoader(loader, virtualFiles);
+
+    // Test functionality works
+    const response = await window.fetch("/@file/test.txt");
+    const text = await response.text();
+    expect(text).toBe("test");
+
+    const content = await loader.load("/@file/test.txt");
+    expect(content).toBe("test");
+
+    unpatchFetch2();
+    unpatchLoader2();
+
+    // Functions should be restored
+    expect(window.fetch).toBe(originalFetch);
+
+    // Test that the loader functions are functional (they should work normally)
+    try {
+      await loader.load("http://example.com/test.json");
+    } catch (error) {
+      // Expected to fail for non-existent URLs, but the function should be callable
+      expect(error).toBeDefined();
+    }
+  });
+
+  it("should handle Request objects in patchFetch", async () => {
+    const virtualFiles = {
+      "/@file/request-test.txt":
+        "data:text/plain;base64,UmVxdWVzdCB0ZXN0" as DataURLString,
+    };
+
+    const unpatch = patchFetch(virtualFiles);
+
+    // Use a full URL for the Request constructor
+    const request = new Request("http://example.com/@file/request-test.txt");
+    const response = await window.fetch(request);
+    const text = await response.text();
+
+    expect(text).toBe("Request test");
+
+    unpatch();
+  });
+
+  it("should handle malformed URLs gracefully", async () => {
+    const virtualFiles = {};
+    const unpatch = patchFetch(virtualFiles);
+
+    // Mock Logger.error to avoid test output
+    const loggerSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(Functions.NOOP);
+
+    // This should catch the error and fallback to original fetch
+    try {
+      await window.fetch("not-a-valid-url");
+      // If it doesn't throw, that's also fine (fallback behavior)
+    } catch (error) {
+      // Expected behavior - invalid URLs should be handled gracefully
+      expect(error).toBeDefined();
+    }
+
+    unpatch();
+    loggerSpy.mockRestore();
+  });
 });

package/src/core/static/files.ts

@@ -24,20 +24,15 @@ export function patchFetch(
     }
 
     try {
-      const url =
-        urlString.startsWith("/") || urlString.startsWith("./")
-          ? new URL(urlString, window.location.origin)
-          : new URL(urlString);
-
-      const filePath = url.pathname;
-      if (files[filePath]) {
-        const base64 = files[filePath];
+      const vfile = maybeGetVirtualFile(urlString, files);
+      if (vfile) {
+        const base64 = vfile;
         // Convert data URL to blob
         const response = await originalFetch(base64);
         const blob = await response.blob();
         return new Response(blob, {
           headers: {
-            "Content-Type": getContentType(filePath),
+            "Content-Type": getContentType(urlString),
           },
         });
       }
@@ -77,30 +72,8 @@ export function patchVegaLoader(
   const originalHttp = loader.http.bind(loader);
   const originalLoad = loader.load.bind(loader);
 
-  function maybeGetVirtualFile(url: string): string | undefined {
-    const pathname = new URL(url, document.baseURI).pathname;
-
-    // If if the URL starts with file://, then using the document.baseURI
-    // will not work. In this case, should just chop off from /@file/...
-    if (url.startsWith("file://")) {
-      const indexOfFile = url.indexOf("/@file/");
-      if (indexOfFile !== -1) {
-        url = files[url.slice(indexOfFile)];
-      }
-    }
-
-    // Few variations to grab the URL.
-    // This can happen if a static file was open at file:// or https://
-    return (
-      files[url] ||
-      files[withoutLeadingDot(url)] ||
-      files[pathname] ||
-      files[withoutLeadingDot(pathname)]
-    );
-  }
-
   loader.http = async (url: string) => {
-    const vfile = maybeGetVirtualFile(url);
+    const vfile = maybeGetVirtualFile(url, files);
     if (vfile) {
       // If the file is a virtual file, fetch it
       return await window.fetch(vfile).then((r) => r.text());
@@ -119,7 +92,7 @@ export function patchVegaLoader(
   };
 
   loader.load = async (url: string) => {
-    const vfile = maybeGetVirtualFile(url);
+    const vfile = maybeGetVirtualFile(url, files);
     if (vfile) {
       // If the file is a virtual file, fetch it
       return await window.fetch(vfile).then((r) => r.text());
@@ -146,3 +119,32 @@ export function patchVegaLoader(
 function withoutLeadingDot(path: string): string {
   return path.startsWith(".") ? path.slice(1) : path;
 }
+
+function maybeGetVirtualFile(
+  url: string,
+  files: StaticVirtualFiles,
+): string | undefined {
+  let base = document.baseURI;
+  if (base.startsWith("blob:")) {
+    base = base.replace("blob:", "");
+  }
+  const pathname = new URL(url, base).pathname;
+
+  // If if the URL starts with file://, then using the document.baseURI
+  // will not work. In this case, should just chop off from /@file/...
+  if (url.startsWith("file://")) {
+    const indexOfFile = url.indexOf("/@file/");
+    if (indexOfFile !== -1) {
+      url = url.slice(indexOfFile);
+    }
+  }
+
+  // Few variations to grab the URL.
+  // This can happen if a static file was open at file:// or https://
+  return (
+    files[url] ||
+    files[withoutLeadingDot(url)] ||
+    files[pathname] ||
+    files[withoutLeadingDot(pathname)]
+  );
+}

package/dist/assets/_baseMap-D0odIxUE.js

@@ -1 +0,0 @@
-import{b as m}from"./_baseEach-Bp57hest.js";import{x as s}from"./index-fffF5hyA.js";function e(r,o){var a=-1,t=s(r)?Array(r.length):[];return m(r,function(n,f,i){t[++a]=o(n,f,i)}),t}export{e as b};

package/dist/assets/channel-COf2II2e.js

@@ -1 +0,0 @@
-import{U as s,C as o}from"./mermaid-Co0X0ppY.js";const n=(a,r)=>s.lang.round(o.parse(a)[r]);export{n as c};

package/dist/assets/classDiagram-M3E45YP4-DLy_0M38.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as t,C as o}from"./chunk-SZ463SBG-DgTD1nXW.js";import{_ as e}from"./mermaid-Co0X0ppY.js";import"./transform-B8bpuzxV.js";import"./chunk-E2GYISFI-SbTvBHWD.js";import"./chunk-BFAMUDN2-C_ssuRFB.js";import"./chunk-SKB7J2MH-D47zuUjI.js";import"./index-fffF5hyA.js";import"./step-BwsUM5iJ.js";import"./timer-BwIYMJWC.js";var i={parser:t,get db(){return new o},renderer:s,styles:a,init:e(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{i as diagram};

package/dist/assets/classDiagram-v2-YAWTLIQI-DLy_0M38.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as t,C as o}from"./chunk-SZ463SBG-DgTD1nXW.js";import{_ as e}from"./mermaid-Co0X0ppY.js";import"./transform-B8bpuzxV.js";import"./chunk-E2GYISFI-SbTvBHWD.js";import"./chunk-BFAMUDN2-C_ssuRFB.js";import"./chunk-SKB7J2MH-D47zuUjI.js";import"./index-fffF5hyA.js";import"./step-BwsUM5iJ.js";import"./timer-BwIYMJWC.js";var i={parser:t,get db(){return new o},renderer:s,styles:a,init:e(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{i as diagram};

package/dist/assets/clone-CLl10UdK.js

@@ -1 +0,0 @@
-import{b as n}from"./_baseUniq-Dc93gwgs.js";function o(r){return n(r,4)}export{o as c};

package/dist/assets/infoDiagram-LHK5PUON-CkfJu9Qh.js

@@ -1,2 +0,0 @@
-import{_ as a,l as i,I as s,d as p,K as n}from"./mermaid-Co0X0ppY.js";import{p as m}from"./treemap-75Q7IDZK-D8nmNQUP.js";import"./index-fffF5hyA.js";import"./transform-B8bpuzxV.js";import"./timer-BwIYMJWC.js";import"./step-BwsUM5iJ.js";import"./_baseEach-Bp57hest.js";import"./_baseUniq-Dc93gwgs.js";import"./min-CxjLn3lS.js";import"./_baseMap-D0odIxUE.js";import"./clone-CLl10UdK.js";import"./_createAggregator-DL75L2j7.js";var d={parse:a(async r=>{const t=await m("info",r);i.debug(t)},"parse")},g={version:n.version+""},v={parser:d,db:{getVersion:a(()=>g.version,"getVersion")},renderer:{draw:a((r,t,o)=>{i.debug(`rendering info diagram
-`+r);const e=s(t);p(e,100,400,!0),e.append("g").append("text").attr("x",100).attr("y",40).attr("class","version").attr("font-size",32).style("text-anchor","middle").text(`v${o}`)},"draw")}};export{v as diagram};

package/dist/assets/stateDiagram-v2-5AN5P6BG-C3Ibkepp.js

@@ -1 +0,0 @@
-import{s as t,b as a,a as e,S as o}from"./chunk-OW32GOEJ-DqkzVAPz.js";import{_ as s}from"./mermaid-Co0X0ppY.js";import"./transform-B8bpuzxV.js";import"./chunk-BFAMUDN2-C_ssuRFB.js";import"./chunk-SKB7J2MH-D47zuUjI.js";import"./index-fffF5hyA.js";import"./step-BwsUM5iJ.js";import"./timer-BwIYMJWC.js";var i={parser:e,get db(){return new o(2)},renderer:a,styles:t,init:s(r=>{r.state||(r.state={}),r.state.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{i as diagram};