@tscircuit/eval 0.0.316 → 0.0.318

package/lib/runner/resolveFilePath.ts

@@ -51,7 +51,7 @@ export const resolveFilePath = (
   }
 
   // Search for file with a set of different extensions
-  const extension = ["tsx", "ts", "json", "js", "jsx", "obj"]
+  const extension = ["tsx", "ts", "json", "js", "jsx", "obj", "gltf", "glb"]
   for (const ext of extension) {
     const possibleFilePath = `${normalizedResolvedPath}.${ext}`
     if (normalizedFilePathMap.has(possibleFilePath)) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/eval",
   "main": "dist/lib/index.js",
-  "version": "0.0.316",
+  "version": "0.0.318",
   "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",
@@ -57,7 +57,7 @@
     "@tscircuit/checks": "^0.0.71",
     "@tscircuit/circuit-json-flex": "^0.0.3",
     "@tscircuit/circuit-json-util": "^0.0.67",
-    "@tscircuit/core": "^0.0.715",
+    "@tscircuit/core": "^0.0.719",
     "@tscircuit/footprinter": "^0.0.236",
     "@tscircuit/import-snippet": "^0.0.4",
     "@tscircuit/infgrid-ijump-astar": "^0.0.33",
@@ -67,11 +67,11 @@
     "@tscircuit/math-utils": "^0.0.21",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/parts-engine": "^0.0.8",
-    "@tscircuit/props": "0.0.313",
+    "@tscircuit/props": "0.0.319",
     "@tscircuit/schematic-autolayout": "^0.0.6",
     "@tscircuit/schematic-match-adapt": "^0.0.16",
     "@tscircuit/schematic-trace-solver": "^0.0.36",
-    "@tscircuit/simple-3d-svg": "^0.0.38",
+    "@tscircuit/simple-3d-svg": "^0.0.41",
     "@types/babel__standalone": "^7.1.9",
     "@types/bun": "^1.2.16",
     "@types/debug": "^4.1.12",
@@ -82,11 +82,11 @@
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.12",
     "chokidar-cli": "^3.0.0",
-    "circuit-json": "^0.0.249",
+    "circuit-json": "^0.0.250",
     "circuit-json-to-bpc": "^0.0.13",
     "circuit-json-to-connectivity-map": "^0.0.22",
-    "circuit-json-to-simple-3d": "^0.0.6",
-    "circuit-to-svg": "^0.0.185",
+    "circuit-json-to-simple-3d": "^0.0.8",
+    "circuit-to-svg": "^0.0.189",
     "comlink": "^4.4.2",
     "concurrently": "^9.1.2",
     "connectivity-map": "^1.0.0",

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

@@ -0,0 +1,78 @@
+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/webworker/import-local-file.ts

@@ -1,5 +1,8 @@
 import * as Babel from "@babel/standalone"
-import { resolveFilePathOrThrow } from "lib/runner/resolveFilePath"
+import {
+  resolveFilePath,
+  resolveFilePathOrThrow,
+} from "lib/runner/resolveFilePath"
 import { dirname } from "lib/utils/dirname"
 import { getImportsFromCode } from "lib/utils/get-imports-from-code"
 import { evalCompiledJs } from "./eval-compiled-js"
@@ -41,6 +44,61 @@ export const importLocalFile = async (
       __esModule: true,
       default: objUrl,
     }
+  } 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,
+    }
   } else if (fsPath.endsWith(".tsx") || fsPath.endsWith(".ts")) {
     const importNames = getImportsFromCode(fileContent)