@tscircuit/eval 0.0.287 → 0.0.289

package/tests/features/fetch-proxy/fetch-proxy-validation.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "bun:test"
+import { createCircuitWebWorker } from "lib"
+import { repoFileUrl } from "tests/fixtures/resourcePaths"
+
+describe("fetch proxy validation", () => {
+  it("should NOT proxy fetch requests when enableFetchProxy is false (default)", async () => {
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: repoFileUrl("dist/webworker/entrypoint.js").href,
+      // enableFetchProxy not set, should default to false
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "worker_fetch") messages.push(event.data)
+    })
+
+    await worker.execute(`
+// Test that fetch calls are NOT proxied when enableFetchProxy is false
+fetch("https://example.com/test")
+  .catch(() => {}); // Ignore errors, we just want to see if it's proxied
+`)
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    // Should NOT have received any worker_fetch messages
+    expect(messages.length).toBe(0)
+
+    await worker.kill()
+  })
+
+  it("should proxy fetch requests when enableFetchProxy is true", async () => {
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: repoFileUrl("dist/webworker/entrypoint.js").href,
+      enableFetchProxy: true,
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "worker_fetch") messages.push(event.data)
+    })
+
+    await worker.execute(`
+// Test that fetch calls are proxied when enableFetchProxy is true
+fetch("https://example.com/test")
+  .catch(() => {}); // Ignore errors, we just want to see if it's proxied
+`)
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    // Should have received a worker_fetch message indicating the proxy is working
+    expect(messages.length).toBeGreaterThan(0)
+    expect(messages[0].type).toBe("worker_fetch")
+    expect(messages[0].input).toBe("https://example.com/test")
+
+    await worker.kill()
+  })
+
+  it("should handle fetch errors properly through proxy when enabled", async () => {
+    // This test verifies that the fetch proxy correctly handles and forwards errors
+    const originalFetch = globalThis.fetch
+    const fakeFetch = async () => {
+      throw new Error("Network error")
+    }
+    globalThis.fetch = fakeFetch as any
+
+    const worker = await createCircuitWebWorker({
+      webWorkerUrl: repoFileUrl("dist/webworker/entrypoint.js").href,
+      enableFetchProxy: true,
+    })
+
+    const rawWorker: Worker = (worker as any).__rawWorker
+    const messages: any[] = []
+    rawWorker.addEventListener("message", (event) => {
+      if (event.data?.type === "fetch_error") messages.push(event.data)
+    })
+
+    await worker.execute(`
+fetch("https://example.com/test")
+  .catch(e => {
+    postMessage({ type: "fetch_error", name: e.name, message: e.message });
+  });
+`)
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    expect(messages).toEqual([
+      { type: "fetch_error", name: "Error", message: "Network error" },
+    ])
+
+    await worker.kill()
+    globalThis.fetch = originalFetch
+  })
+})

package/tests/{kill.test.ts → features/kill.test.ts}

@@ -1,11 +1,13 @@
 import { describe, it, expect } from "bun:test"
-import { createCircuitWebWorker } from "../lib"
+import { createCircuitWebWorker } from "lib"
 
 describe("kill method", () => {
   it("should immediately terminate the worker", async () => {
     const worker = await createCircuitWebWorker({
-      webWorkerUrl: new URL("../dist/webworker/entrypoint.js", import.meta.url)
-        .href,
+      webWorkerUrl: new URL(
+        "../../dist/webworker/entrypoint.js",
+        import.meta.url,
+      ).href,
     })
 
     // Ensure worker is running

package/tests/{manual-edits.test.tsx → features/manual-edits.test.tsx}

@@ -59,7 +59,7 @@ const example2 = {
 
 test("example1: Manual edits in entrypoint.tsx file", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/index.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/index.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({
@@ -89,7 +89,7 @@ test("example1: Manual edits in entrypoint.tsx file", async () => {
 
 test("example2: Manual edits in manual-edits.json file", async () => {
   const circuitWebWorker = await createCircuitWebWorker({
-    webWorkerUrl: new URL("../webworker/index.ts", import.meta.url),
+    webWorkerUrl: new URL("../../webworker/index.ts", import.meta.url),
   })
 
   await circuitWebWorker.executeWithFsMap({

package/tests/fixtures/resourcePaths.ts

@@ -0,0 +1,3 @@
+export const repoFileUrl = (pathFromRoot: string) => {
+  return new URL(`../../${pathFromRoot}`, import.meta.url)
+}

package/webworker/entrypoint.ts

@@ -11,11 +11,13 @@ import {
   type ExecutionContext,
 } from "./execution-context"
 import { importEvalPath } from "./import-eval-path"
-import { normalizeFsMap } from "../lib/runner/normalizeFsMap"
+import { normalizeFsMap } from "lib/runner/normalizeFsMap"
 import type { RootCircuit } from "@tscircuit/core"
 import { setupDefaultEntrypointIfNeeded } from "lib/runner/setupDefaultEntrypointIfNeeded"
+import { setupFetchProxy } from "./fetchProxy"
 
 globalThis.React = React
+setupFetchProxy()
 
 let executionContext: ExecutionContext | null = null
 
@@ -124,7 +126,10 @@ const webWorkerApi = {
       for (const event in eventListeners) {
         for (const listener of eventListeners[event]) {
           const circuit = executionContext.circuit as unknown as {
-            removeListener?: (event: string, listener: Function) => void
+            removeListener?: (
+              event: string,
+              listener: (...args: any[]) => void,
+            ) => void
           }
           if (typeof circuit.removeListener === "function") {
             circuit.removeListener(event, listener)

package/webworker/fetchProxy.ts

@@ -0,0 +1,83 @@
+export const setupFetchProxy = () => {
+  const pendingRequests = new Map<
+    number,
+    { resolve: (value: Response) => void; reject: (reason: any) => void }
+  >()
+  let requestCounter = 0
+
+  function fetchProxy(
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> {
+    const requestId = ++requestCounter
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(requestId, { resolve, reject })
+      let url: string
+      let requestInit: any = init ? { ...init } : {}
+
+      if (typeof input === "string" || input instanceof URL) {
+        url = input.toString()
+      } else {
+        url = input.url
+        requestInit = {
+          ...requestInit,
+          method: input.method,
+          headers: (() => {
+            const obj: Record<string, string> = {}
+            input.headers.forEach((value, key) => {
+              obj[key] = value
+            })
+            return obj
+          })(),
+          body: input.bodyUsed ? undefined : (input as any).body,
+        }
+      }
+
+      if (requestInit.headers instanceof Headers) {
+        const obj: Record<string, string> = {}
+        requestInit.headers.forEach((value: string, key: string) => {
+          obj[key] = value
+        })
+        requestInit.headers = obj
+      }
+      ;(globalThis as any).postMessage({
+        type: "worker_fetch",
+        requestId,
+        input: url,
+        init: requestInit,
+      })
+    })
+  }
+
+  function handleMessage(event: MessageEvent) {
+    const data = event.data
+    if (!data) return
+
+    if (data.type === "override_global_fetch") {
+      ;(globalThis as any).fetch = fetchProxy
+      return
+    }
+
+    if (data.type === "worker_fetch_result") {
+      const handlers = pendingRequests.get(data.requestId)
+      if (!handlers) return
+      pendingRequests.delete(data.requestId)
+
+      if (data.success) {
+        const resp = new Response(data.response.body, {
+          status: data.response.status,
+          statusText: data.response.statusText,
+          headers: data.response.headers,
+        })
+        handlers.resolve(resp)
+      } else {
+        const err = new Error(data.error.message)
+        if (data.error.name) err.name = data.error.name
+        if (data.error.stack) err.stack = data.error.stack
+        handlers.reject(err)
+      }
+    }
+  }
+
+  globalThis.addEventListener("message", handleMessage)
+}

package/webworker/import-snippet.ts

@@ -1,8 +1,5 @@
 import { evalCompiledJs } from "./eval-compiled-js"
 import type { ExecutionContext } from "./execution-context"
-import * as Babel from "@babel/standalone"
-import { importLocalFile } from "./import-local-file"
-import { importEvalPath } from "./import-eval-path"
 
 export async function importSnippet(
   importName: string,
@@ -12,7 +9,8 @@ export async function importSnippet(
   const { preSuppliedImports } = ctx
   const fullSnippetName = importName.replace("@tsci/", "").replace(".", "/")
 
-  const { cjs, error } = await fetch(`${ctx.cjsRegistryUrl}/${fullSnippetName}`)
+  const { cjs, error } = await globalThis
+    .fetch(`${ctx.cjsRegistryUrl}/${fullSnippetName}`)
     .then(async (res) => ({ cjs: await res.text(), error: null }))
     .catch((e) => ({ error: e, cjs: null }))