@tscircuit/eval 0.0.320 → 0.0.322

package/lib/index.ts

@@ -2,3 +2,4 @@ export * from "./runner"
 export * from "./worker"
 export * from "./getPossibleEntrypointComponentPaths"
 export * from "./getPlatformConfig"
+export * from "./shared/static-asset-extensions"

package/lib/runner/index.ts

@@ -1,3 +1,4 @@
 export * from "./CircuitRunner"
 export * from "./runTscircuitCode"
 export * from "./runTscircuitModule"
+export * from "../shared/static-asset-extensions"

package/lib/shared/static-asset-extensions.ts

@@ -0,0 +1,10 @@
+export const STATIC_ASSET_EXTENSIONS = [
+  ".glb",
+  ".kicad_mod",
+  ".gltf",
+  ".obj",
+  ".stl",
+]
+
+export const isStaticAssetPath = (path: string) =>
+  STATIC_ASSET_EXTENSIONS.some((ext) => path.endsWith(ext))

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/eval",
   "main": "dist/lib/index.js",
-  "version": "0.0.320",
+  "version": "0.0.322",
   "type": "module",
   "scripts": {
     "build": "bun run build:lib && bun run build:webworker && bun run build:blob-url && bun run build:runner && bun run build:worker-wrapper",
@@ -67,7 +67,7 @@
     "@tscircuit/math-utils": "^0.0.21",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/parts-engine": "^0.0.8",
-    "@tscircuit/props": "0.0.319",
+    "@tscircuit/props": "0.0.320",
     "@tscircuit/schematic-autolayout": "^0.0.6",
     "@tscircuit/schematic-match-adapt": "^0.0.16",
     "@tscircuit/schematic-trace-solver": "^0.0.36",

package/tests/features/static-file-imports/static-file-import.test.ts

@@ -0,0 +1,50 @@
+import { expect, test } from "bun:test"
+import { createCircuitWebWorker } from "lib"
+import { repoFileUrl } from "tests/fixtures/resourcePaths"
+
+test("should import .glb file as string URL when projectBaseUrl is configured", async () => {
+  const circuitWebWorker = createCircuitWebWorker({
+    webWorkerUrl: repoFileUrl("dist/webworker/entrypoint.js").href,
+    platform: {
+      projectBaseUrl: "https://example.com/assets",
+    },
+  })
+
+  const worker = await circuitWebWorker
+
+  await worker.executeWithFsMap({
+    fsMap: {
+      "index.tsx": `
+import glbUrl from "./model.glb";
+import kicadMod from "./footprint.kicad_mod";
+
+export default () => {
+  return (
+    <board width="10mm" height="10mm">
+      <resistor resistance="1k" footprint="0402" name="R1" cadModel={{
+        glbUrl
+      }} />
+    </board>
+  );
+};
+        `,
+      "model.glb": "__STATIC_ASSET__",
+      "footprint.kicad_mod": "__STATIC_ASSET__",
+    },
+    mainComponentPath: "index.tsx",
+  })
+
+  await worker.renderUntilSettled()
+
+  // Verify the circuit rendered successfully (imports worked)
+  const circuitJson = await worker.getCircuitJson()
+  expect(circuitJson).toBeDefined()
+
+  const cadComponent = circuitJson.find((e) => e.type === "cad_component")!
+
+  expect(cadComponent.model_glb_url).toBe(
+    "https://example.com/assets/model.glb",
+  )
+
+  await worker.kill()
+})

package/webworker/import-local-file.ts

@@ -9,6 +9,7 @@ import { evalCompiledJs } from "./eval-compiled-js"
 import type { ExecutionContext } from "./execution-context"
 import { importEvalPath } from "./import-eval-path"
 import Debug from "debug"
+import { isStaticAssetPath } from "lib/shared/static-asset-extensions"
 
 const debug = Debug("tsci:eval:import-local-file")
 
@@ -24,8 +25,9 @@ export const importLocalFile = async (
   const { fsMap, preSuppliedImports } = ctx
 
   const fsPath = resolveFilePathOrThrow(importName, fsMap)
+  const isStaticAsset = isStaticAssetPath(fsPath)
   debug("fsPath:", fsPath)
-  if (!ctx.fsMap[fsPath]) {
+  if (!ctx.fsMap[fsPath] && !isStaticAsset) {
     debug("fsPath not found in fsMap:", fsPath)
     throw new Error(`File "${fsPath}" not found`)
   }
@@ -37,75 +39,13 @@ export const importLocalFile = async (
       __esModule: true,
       default: jsonData,
     }
-  } else if (fsPath.endsWith(".obj")) {
-    const objBlob = new Blob([fileContent], { type: "model/obj" })
-    const objUrl = URL.createObjectURL(objBlob)
+  } else if (isStaticAsset) {
+    const platformConfig = ctx.circuit.platform
+    // Use projectBaseUrl for static file imports
+    const staticUrl = `${platformConfig?.projectBaseUrl ?? ""}/${fsPath.startsWith("./") ? fsPath.slice(2) : fsPath}`
     preSuppliedImports[fsPath] = {
       __esModule: true,
-      default: objUrl,
-    }
-  } else if (fsPath.endsWith(".glb")) {
-    const glbArray = Uint8Array.from(fileContent, (c) => c.charCodeAt(0))
-    const glbBlob = new Blob([glbArray], { type: "model/gltf-binary" })
-    const glbUrl = URL.createObjectURL(glbBlob)
-    preSuppliedImports[fsPath] = {
-      __esModule: true,
-      default: glbUrl,
-    }
-  } else if (fsPath.endsWith(".gltf")) {
-    const gltfJson = JSON.parse(fileContent)
-    const fileDir = dirname(fsPath)
-
-    const inlineUri = (uri: string) => {
-      if (uri && !uri.startsWith("data:") && !uri.startsWith("http")) {
-        const assetPath = resolveFilePath(uri, fsMap, fileDir)
-        if (!assetPath) {
-          console.warn(`Asset not found for URI: ${uri} in ${fsPath}`)
-          return uri
-        }
-        const assetContentStr = fsMap[assetPath]
-
-        try {
-          const base64Content = btoa(assetContentStr)
-
-          let mimeType = "application/octet-stream"
-          if (assetPath.endsWith(".bin")) {
-            mimeType = "application/octet-stream"
-          } else if (assetPath.endsWith(".png")) {
-            mimeType = "image/png"
-          } else if (
-            assetPath.endsWith(".jpeg") ||
-            assetPath.endsWith(".jpg")
-          ) {
-            mimeType = "image/jpeg"
-          }
-
-          return `data:${mimeType};base64,${base64Content}`
-        } catch (e) {
-          console.error(`Failed to encode asset to base64: ${assetPath}`, e)
-          return uri
-        }
-      }
-      return uri
-    }
-
-    if (gltfJson.buffers) {
-      for (const buffer of gltfJson.buffers) {
-        if (buffer.uri) buffer.uri = inlineUri(buffer.uri)
-      }
-    }
-    if (gltfJson.images) {
-      for (const image of gltfJson.images) {
-        if (image.uri) image.uri = inlineUri(image.uri)
-      }
-    }
-
-    const gltfContent = JSON.stringify(gltfJson)
-    const gltfBlob = new Blob([gltfContent], { type: "model/gltf+json" })
-    const gltfUrl = URL.createObjectURL(gltfBlob)
-    preSuppliedImports[fsPath] = {
-      __esModule: true,
-      default: gltfUrl,
+      default: staticUrl,
     }
   } else if (fsPath.endsWith(".tsx") || fsPath.endsWith(".ts")) {
     const importNames = getImportsFromCode(fileContent)

package/tests/features/import-glb-file.test.tsx

@@ -1,54 +0,0 @@
-import { expect, test } from "bun:test"
-import type { AnyCircuitElement, CadComponent } from "circuit-json"
-import { CircuitRunner } from "lib/runner/CircuitRunner"
-
-test("should support importing .glb files", async () => {
-  const runner = new CircuitRunner()
-
-  const glbContent = "This is a dummy glb file"
-
-  const fsMap = {
-    "my-model.glb": glbContent,
-    "user-code.tsx": `
-        import myGlbUrl from "./my-model.glb"
-
-        export default () => (
-            <chip
-                name="C1"
-                cadModel={{
-                    gltfUrl: myGlbUrl,
-                }}
-            />
-        )
-    `,
-  }
-
-  await runner.executeWithFsMap({
-    fsMap,
-    mainComponentPath: "user-code.tsx",
-  })
-
-  await runner.renderUntilSettled()
-  const circuitJson = await runner.getCircuitJson()
-
-  const chip =
-    (circuitJson.find(
-      (elm) => elm.type === "source_component" && elm.name === "C1",
-    ) as AnyCircuitElement) || undefined
-  const cadModel =
-    (circuitJson.find((elm) => elm.type === "cad_component") as CadComponent) ||
-    undefined
-
-  expect(chip).toBeDefined()
-  expect(cadModel?.model_gltf_url).toBeString()
-  expect(cadModel?.model_gltf_url).toStartWith("blob:")
-
-  if (cadModel?.model_gltf_url) {
-    const response = await fetch(cadModel.model_gltf_url)
-    const arrayBuffer = await response.arrayBuffer()
-    const text = new TextDecoder().decode(arrayBuffer)
-    expect(text).toBe(glbContent)
-  }
-
-  await runner.kill()
-})

package/tests/features/import-gltf-file.test.tsx

@@ -1,78 +0,0 @@
-import { expect, test } from "bun:test"
-import type { AnyCircuitElement, CadComponent } from "circuit-json"
-import { CircuitRunner } from "lib/runner/CircuitRunner"
-
-test("should support importing .gltf files with binary", async () => {
-  const runner = new CircuitRunner()
-
-  const gltfContent = {
-    asset: { version: "2.0" },
-    scenes: [{ nodes: [0] }],
-    nodes: [{ mesh: 0 }],
-    meshes: [
-      {
-        primitives: [{ attributes: { POSITION: 0 } }],
-      },
-    ],
-    buffers: [{ uri: "model.bin", byteLength: 36 }],
-    bufferViews: [{ buffer: 0, byteOffset: 0, byteLength: 36 }],
-    accessors: [
-      {
-        bufferView: 0,
-        componentType: 5126, // FLOAT
-        count: 3,
-        type: "VEC3",
-      },
-    ],
-  }
-
-  const binContent = "This is a dummy binary file content.".padEnd(36, "\0")
-
-  const fsMap = {
-    "my-model.gltf": JSON.stringify(gltfContent),
-    "model.bin": binContent,
-    "user-code.tsx": `
-        import myGltfUrl from "./my-model.gltf"
-
-        export default () => (
-            <chip
-                name="C1"
-                cadModel={{
-                    gltfUrl: myGltfUrl,
-                }}
-            />
-        )
-    `,
-  }
-
-  await runner.executeWithFsMap({
-    fsMap,
-    mainComponentPath: "user-code.tsx",
-  })
-
-  await runner.renderUntilSettled()
-  const circuitJson = await runner.getCircuitJson()
-
-  const chip =
-    (circuitJson.find(
-      (elm) => elm.type === "source_component" && elm.name === "C1",
-    ) as AnyCircuitElement) || undefined
-  const cadModel =
-    (circuitJson.find((elm) => elm.type === "cad_component") as CadComponent) ||
-    undefined
-
-  expect(chip).toBeDefined()
-  expect(cadModel?.model_gltf_url).toBeString()
-  expect(cadModel?.model_gltf_url).toStartWith("blob:")
-
-  if (cadModel?.model_gltf_url) {
-    const response = await fetch(cadModel.model_gltf_url)
-    const text = await response.text()
-    const json = JSON.parse(text)
-    expect(json.buffers[0].uri).toStartWith(
-      "data:application/octet-stream;base64,",
-    )
-  }
-
-  await runner.kill()
-})

package/tests/features/import-obj-file.test.tsx

@@ -1,49 +0,0 @@
-import { expect, test } from "bun:test"
-import type {
-  AnyCircuitElement,
-  AnySourceComponent,
-  CadComponent,
-} from "circuit-json"
-import { CircuitRunner } from "lib/runner/CircuitRunner"
-
-test("should support importing .obj files", async () => {
-  const runner = new CircuitRunner()
-
-  const fsMap = {
-    "my-model.obj": `v 1.0 1.0 0.0`, // some dummy obj content
-    "user-code.tsx": `
-        import myObjUrl from "./my-model.obj"
-
-        export default () => (
-            <chip
-                name="C1"
-                cadModel={{
-                    objUrl: myObjUrl,
-                }}
-            />
-        )
-    `,
-  }
-
-  await runner.executeWithFsMap({
-    fsMap,
-    mainComponentPath: "user-code.tsx",
-  })
-
-  await runner.renderUntilSettled()
-  const circuitJson = await runner.getCircuitJson()
-
-  const chip =
-    (circuitJson.find(
-      (elm) => elm.type === "source_component" && elm.name === "C1",
-    ) as AnyCircuitElement) || undefined
-  const cadModel =
-    (circuitJson.find((elm) => elm.type === "cad_component") as CadComponent) ||
-    undefined
-
-  expect(chip).toBeDefined()
-  expect(cadModel?.model_obj_url).toBeString()
-  expect(cadModel?.model_obj_url).toStartWith("blob:")
-
-  await runner.kill()
-})