@tscircuit/eval 0.0.363 → 0.0.365

package/webworker/entrypoint.ts

@@ -1,227 +0,0 @@
-import type { AnyCircuitElement } from "circuit-json"
-import * as Comlink from "comlink"
-import type {
-  InternalWebWorkerApi,
-  WebWorkerConfiguration,
-} from "lib/shared/types"
-import * as React from "react"
-import type { PlatformConfig } from "@tscircuit/props"
-import {
-  createExecutionContext,
-  type ExecutionContext,
-} from "./execution-context"
-import { importEvalPath } from "./import-eval-path"
-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
-let debugNamespace: string | undefined
-
-const circuitRunnerConfiguration: WebWorkerConfiguration = {
-  snippetsApiBaseUrl: "https://registry-api.tscircuit.com",
-  cjsRegistryUrl: "https://cjs.tscircuit.com",
-  verbose: false,
-  platform: undefined,
-  projectConfig: undefined,
-}
-
-const eventListeners: Record<string, ((...args: any[]) => void)[]> = {}
-
-// Helper to deserialize React elements from cross-worker communication
-function deserializeReactElement(serialized: any): any {
-  if (!serialized || typeof serialized !== "object") {
-    return serialized
-  }
-
-  if (serialized.__isSerializedReactElement) {
-    const props = deserializeProps(serialized.props)
-    return React.createElement(serialized.type, props)
-  }
-
-  return serialized
-}
-
-function deserializeProps(props: any): any {
-  if (!props || typeof props !== "object") {
-    return props
-  }
-
-  const deserialized: any = {}
-  for (const [key, value] of Object.entries(props)) {
-    if (key === "children") {
-      if (Array.isArray(value)) {
-        deserialized.children = value.map(deserializeReactElement)
-      } else {
-        deserialized.children = deserializeReactElement(value)
-      }
-    } else {
-      deserialized[key] = value
-    }
-  }
-  return deserialized
-}
-
-function bindEventListeners(circuit: RootCircuit) {
-  for (const event in eventListeners) {
-    for (const listener of eventListeners[event]) {
-      circuit.on(event as any, listener as any)
-    }
-  }
-}
-
-const webWorkerApi = {
-  setSnippetsApiBaseUrl: async (baseUrl: string) => {
-    circuitRunnerConfiguration.snippetsApiBaseUrl = baseUrl
-  },
-  setPlatformConfig: async (platform: PlatformConfig) => {
-    circuitRunnerConfiguration.platform = platform
-  },
-  setProjectConfig: async (project: Partial<PlatformConfig>) => {
-    circuitRunnerConfiguration.projectConfig = project
-  },
-
-  enableDebug: async (namespace: string) => {
-    debugNamespace = namespace
-    if (executionContext) {
-      const circuit = executionContext.circuit as any
-      circuit.enableDebug?.(namespace)
-    }
-  },
-
-  version: async () => {
-    return "0.0.0"
-  },
-
-  async executeWithFsMap(opts: {
-    entrypoint?: string
-    fsMap: Record<string, string>
-    name?: string
-  }): Promise<void> {
-    if (circuitRunnerConfiguration.verbose) {
-      console.log("[Worker] executeWithFsMap called with:", {
-        entrypoint: opts.entrypoint,
-        fsMapKeys: Object.keys(opts.fsMap),
-        name: opts.name,
-      })
-    }
-
-    setupDefaultEntrypointIfNeeded(opts)
-
-    let entrypoint = opts.entrypoint!
-
-    executionContext = createExecutionContext(circuitRunnerConfiguration, {
-      name: opts.name,
-      platform: circuitRunnerConfiguration.platform,
-      projectConfig: circuitRunnerConfiguration.projectConfig,
-      debugNamespace,
-    })
-    bindEventListeners(executionContext.circuit)
-    executionContext.fsMap = normalizeFsMap(opts.fsMap)
-    if (!executionContext.fsMap[entrypoint]) {
-      throw new Error(`Entrypoint "${opts.entrypoint}" not found`)
-    }
-    ;(globalThis as any).__tscircuit_circuit = executionContext.circuit
-
-    if (!entrypoint.startsWith("./")) {
-      entrypoint = `./${entrypoint}`
-    }
-
-    await importEvalPath(entrypoint, executionContext)
-  },
-
-  async execute(code: string, opts: { name?: string } = {}) {
-    if (circuitRunnerConfiguration.verbose) {
-      console.log("[Worker] execute called with code length:", code.length)
-    }
-    executionContext = createExecutionContext(circuitRunnerConfiguration, {
-      ...opts,
-      platform: circuitRunnerConfiguration.platform,
-      projectConfig: circuitRunnerConfiguration.projectConfig,
-      debugNamespace,
-    })
-    bindEventListeners(executionContext.circuit)
-    executionContext.fsMap["entrypoint.tsx"] = code
-    ;(globalThis as any).__tscircuit_circuit = executionContext.circuit
-
-    await importEvalPath("./entrypoint.tsx", executionContext)
-  },
-
-  async executeComponent(component: any, opts: { name?: string } = {}) {
-    if (circuitRunnerConfiguration.verbose) {
-      console.log("[Worker] executeComponent called")
-    }
-    executionContext = createExecutionContext(circuitRunnerConfiguration, {
-      ...opts,
-      platform: circuitRunnerConfiguration.platform,
-      projectConfig: circuitRunnerConfiguration.projectConfig,
-      debugNamespace,
-    })
-    bindEventListeners(executionContext.circuit)
-    ;(globalThis as any).__tscircuit_circuit = executionContext.circuit
-
-    let element: any
-    if (typeof component === "function") {
-      element = component()
-    } else if (component && component.__isSerializedReactElement) {
-      element = deserializeReactElement(component)
-    } else {
-      element = component
-    }
-    executionContext.circuit.add(element as any)
-  },
-
-  on: (event: string, callback: (...args: any[]) => void) => {
-    eventListeners[event] ??= []
-    eventListeners[event].push(callback)
-    executionContext?.circuit.on(event as any, callback)
-  },
-
-  renderUntilSettled: async (): Promise<void> => {
-    if (!executionContext) {
-      throw new Error("No circuit has been created")
-    }
-    await executionContext.circuit.renderUntilSettled()
-  },
-
-  getCircuitJson: async (): Promise<AnyCircuitElement[]> => {
-    if (!executionContext) {
-      throw new Error("No circuit has been created")
-    }
-    return executionContext.circuit.getCircuitJson()
-  },
-
-  clearEventListeners: () => {
-    // If there's an active circuit, try to unbind all listeners
-    if (executionContext?.circuit) {
-      for (const event in eventListeners) {
-        for (const listener of eventListeners[event]) {
-          const circuit = executionContext.circuit as unknown as {
-            removeListener?: (
-              event: string,
-              listener: (...args: any[]) => void,
-            ) => void
-          }
-          if (circuit.removeListener) {
-            circuit.removeListener(event, listener)
-          }
-        }
-      }
-    }
-
-    // Clear all stored event listeners
-    for (const event in eventListeners) {
-      delete eventListeners[event]
-    }
-  },
-
-  // Required by InternalWebWorkerApi interface but never called
-  // Worker termination is handled by the main thread
-  kill: async () => {},
-} satisfies InternalWebWorkerApi
-
-Comlink.expose(webWorkerApi)

package/webworker/eval-compiled-js.ts

@@ -1,61 +0,0 @@
-import { resolveFilePath } from "lib/runner/resolveFilePath"
-
-export function evalCompiledJs(
-  compiledCode: string,
-  preSuppliedImports: Record<string, any>,
-  cwd?: string,
-) {
-  ;(globalThis as any).__tscircuit_require = (name: string) => {
-    const resolvedFilePath = resolveFilePath(name, preSuppliedImports, cwd)
-
-    const hasResolvedFilePath =
-      resolvedFilePath && preSuppliedImports[resolvedFilePath]
-
-    if (!preSuppliedImports[name] && !hasResolvedFilePath) {
-      throw new Error(`Import "${name}" not found ${cwd ? `in "${cwd}"` : ""}`)
-    }
-
-    const mod =
-      preSuppliedImports[name] || preSuppliedImports[resolvedFilePath!]
-    return new Proxy(mod, {
-      get(target, prop) {
-        if (!(prop in target)) {
-          if (prop === "default") {
-            if (target.default !== undefined) {
-              return target.default
-            }
-
-            if (target.__esModule) {
-              return undefined
-            }
-
-            if (typeof target === "function" || typeof target === "object") {
-              return target
-            }
-
-            return undefined
-          }
-
-          if (prop === "__esModule") {
-            return true
-          }
-
-          throw new Error(
-            `Component "${String(prop)}" is not exported by "${name}"`,
-          )
-        }
-
-        return target[prop as keyof typeof target]
-      },
-    })
-  }
-
-  const functionBody = `
-  var exports = {};
-  var require = globalThis.__tscircuit_require;
-  var module = { exports };
-  var circuit = globalThis.__tscircuit_circuit;
-  ${compiledCode};
-  return module;`.trim()
-  return Function(functionBody).call(globalThis)
-}

package/webworker/execution-context.ts

@@ -1,64 +0,0 @@
-import { RootCircuit } from "@tscircuit/core"
-import type { WebWorkerConfiguration } from "lib/shared/types"
-import * as tscircuitCore from "@tscircuit/core"
-import * as React from "react"
-import * as tscircuitMathUtils from "@tscircuit/math-utils"
-import type { PlatformConfig } from "@tscircuit/props"
-import { getPlatformConfig } from "lib/getPlatformConfig"
-import Debug from "debug"
-
-const debug = Debug("tsci:eval:execution-context")
-
-export interface ExecutionContext extends WebWorkerConfiguration {
-  fsMap: Record<string, string>
-  entrypoint: string
-  preSuppliedImports: Record<string, any>
-  circuit: RootCircuit
-}
-
-export function createExecutionContext(
-  webWorkerConfiguration: WebWorkerConfiguration,
-  opts: {
-    name?: string
-    platform?: PlatformConfig
-    projectConfig?: Partial<PlatformConfig>
-    debugNamespace?: string
-  } = {},
-): ExecutionContext {
-  globalThis.React = React
-
-  const basePlatform = opts.platform || getPlatformConfig()
-  const platform = opts.projectConfig
-    ? { ...basePlatform, ...opts.projectConfig }
-    : basePlatform
-
-  const circuit = new RootCircuit({
-    platform,
-  })
-
-  if (opts.name) {
-    circuit.name = opts.name
-  }
-
-  if (opts.debugNamespace) {
-    circuit.enableDebug(opts.debugNamespace)
-  }
-
-  return {
-    fsMap: {},
-    entrypoint: "",
-    preSuppliedImports: {
-      "@tscircuit/core": tscircuitCore,
-      tscircuit: tscircuitCore,
-      "@tscircuit/math-utils": tscircuitMathUtils,
-      react: React,
-      debug: Debug,
-
-      // This is usually used as a type import, we can remove the shim when we
-      // ignore type imports in getImportsFromCode
-      "@tscircuit/props": {},
-    },
-    circuit,
-    ...webWorkerConfiguration,
-  }
-}

package/webworker/fetchProxy.ts

@@ -1,83 +0,0 @@
-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-eval-path.ts

@@ -1,78 +0,0 @@
-import type { ExecutionContext } from "./execution-context"
-import { importLocalFile } from "./import-local-file"
-import { importSnippet } from "./import-snippet"
-import { resolveFilePath } from "lib/runner/resolveFilePath"
-import { resolveNodeModule } from "lib/utils/resolve-node-module"
-import { importNodeModule } from "./import-node-module"
-import { importNpmPackage } from "./import-npm-package"
-import Debug from "debug"
-
-const debug = Debug("tsci:eval:import-eval-path")
-
-export async function importEvalPath(
-  importName: string,
-  ctx: ExecutionContext,
-  depth = 0,
-  opts: {
-    cwd?: string
-  } = {},
-) {
-  debug("importEvalPath called with:", {
-    importName,
-    depth,
-    opts,
-  })
-
-  debug(`${"  ".repeat(depth)}➡️`, importName)
-  const { preSuppliedImports } = ctx
-
-  if (preSuppliedImports[importName]) return
-  if (importName.startsWith("./") && preSuppliedImports[importName.slice(2)])
-    return
-
-  if (depth > 5) {
-    console.log("Max depth for imports reached")
-    return
-  }
-
-  if (importName.startsWith("/npm/")) {
-    const pkgName = importName.replace(/^\/npm\//, "").replace(/\/\+esm$/, "")
-    await importNpmPackage(pkgName, ctx, depth)
-    const pkg = preSuppliedImports[pkgName]
-    if (pkg) {
-      preSuppliedImports[importName] = pkg
-    }
-    return
-  }
-
-  const resolvedLocalImportPath = resolveFilePath(
-    importName,
-    ctx.fsMap,
-    opts.cwd,
-  )
-  if (resolvedLocalImportPath) {
-    return importLocalFile(resolvedLocalImportPath, ctx, depth)
-  }
-
-  // Try to resolve from node_modules
-  const resolvedNodeModulePath = resolveNodeModule(
-    importName,
-    ctx.fsMap,
-    opts.cwd || "",
-  )
-  if (resolvedNodeModulePath) {
-    return importNodeModule(importName, ctx, depth)
-  }
-
-  if (importName.startsWith("@tsci/")) {
-    return importSnippet(importName, ctx, depth)
-  }
-
-  if (!importName.startsWith(".") && !importName.startsWith("/")) {
-    return importNpmPackage(importName, ctx, depth)
-  }
-
-  throw new Error(
-    `Unresolved import "${importName}" ${opts.cwd ? `from directory "${opts.cwd}"` : ""}`,
-  )
-}

package/webworker/import-local-file.ts

@@ -1,93 +0,0 @@
-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"
-import type { ExecutionContext } from "./execution-context"
-import { importEvalPath } from "./import-eval-path"
-import Debug from "debug"
-import { isStaticAssetPath } from "lib/shared/static-asset-extensions"
-import { transformWithSucrase } from "./transform-with-sucrase"
-
-const debug = Debug("tsci:eval:import-local-file")
-
-export const importLocalFile = async (
-  importName: string,
-  ctx: ExecutionContext,
-  depth = 0,
-) => {
-  debug("importLocalFile called with:", {
-    importName,
-  })
-
-  const { fsMap, preSuppliedImports } = ctx
-
-  const fsPath = resolveFilePathOrThrow(importName, fsMap)
-  debug("fsPath:", fsPath)
-  if (!ctx.fsMap[fsPath]) {
-    debug("fsPath not found in fsMap:", fsPath)
-    throw new Error(`File "${fsPath}" not found`)
-  }
-  const fileContent = fsMap[fsPath]
-  debug("fileContent:", fileContent?.slice(0, 100))
-  if (fsPath.endsWith(".json")) {
-    const jsonData = JSON.parse(fileContent)
-    preSuppliedImports[fsPath] = {
-      __esModule: true,
-      default: jsonData,
-    }
-  } else if (isStaticAssetPath(fsPath)) {
-    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: staticUrl,
-    }
-  } else if (fsPath.endsWith(".tsx") || fsPath.endsWith(".ts")) {
-    const importNames = getImportsFromCode(fileContent)
-
-    for (const importName of importNames) {
-      if (!preSuppliedImports[importName]) {
-        await importEvalPath(importName, ctx, depth + 1, {
-          cwd: dirname(fsPath),
-        })
-      }
-    }
-
-    try {
-      const transformedCode = transformWithSucrase(fileContent, fsPath)
-      debug("evalCompiledJs called with:", {
-        code: transformedCode.slice(0, 100),
-        dirname: dirname(fsPath),
-      })
-      const importRunResult = evalCompiledJs(
-        transformedCode,
-        preSuppliedImports,
-        dirname(fsPath),
-      )
-      debug("importRunResult:", {
-        fsPath,
-        importRunResult,
-      })
-      preSuppliedImports[fsPath] = importRunResult.exports
-    } catch (error: any) {
-      throw new Error(
-        `Eval compiled js error for "${importName}": ${error.message}`,
-      )
-    }
-  } else if (fsPath.endsWith(".js")) {
-    // For .js files, especially from node_modules, we need to transform them
-    preSuppliedImports[fsPath] = evalCompiledJs(
-      transformWithSucrase(fileContent, fsPath),
-      preSuppliedImports,
-      dirname(fsPath),
-    ).exports
-  } else {
-    throw new Error(
-      `Unsupported file extension "${fsPath.split(".").pop()}" for "${fsPath}"`,
-    )
-  }
-}

package/webworker/import-node-module.ts

@@ -1,54 +0,0 @@
-import { resolveNodeModule } from "lib/utils/resolve-node-module"
-import type { ExecutionContext } from "./execution-context"
-import { importLocalFile } from "./import-local-file"
-
-export const importNodeModule = async (
-  importName: string,
-  ctx: ExecutionContext,
-  depth = 0,
-) => {
-  const { preSuppliedImports } = ctx
-
-  if (preSuppliedImports[importName]) {
-    return
-  }
-
-  const resolvedNodeModulePath = resolveNodeModule(importName, ctx.fsMap, "")
-
-  if (!resolvedNodeModulePath) {
-    throw new Error(`Node module "${importName}" not found`)
-  }
-
-  // Use importLocalFile to handle the node module
-  await importLocalFile(resolvedNodeModulePath, ctx, depth)
-
-  // Map the original import name to the resolved module's exports
-  preSuppliedImports[importName] = preSuppliedImports[resolvedNodeModulePath]
-
-  // Map without node_modules prefix for direct imports
-  const unprefixedPath = resolvedNodeModulePath.replace(/^node_modules\//, "")
-  preSuppliedImports[unprefixedPath] =
-    preSuppliedImports[resolvedNodeModulePath]
-
-  // Handle index files specially
-  if (
-    resolvedNodeModulePath.endsWith("/index.tsx") ||
-    resolvedNodeModulePath.endsWith("/index.ts") ||
-    resolvedNodeModulePath.endsWith("/index.js")
-  ) {
-    const dirPath = resolvedNodeModulePath.replace(/\/index\.(tsx?|js)$/, "")
-    const unprefixedDirPath = dirPath.replace(/^node_modules\//, "")
-    preSuppliedImports[unprefixedDirPath] =
-      preSuppliedImports[resolvedNodeModulePath]
-
-    // Handle scoped packages
-    if (unprefixedDirPath.startsWith("@")) {
-      const scopeParts = unprefixedDirPath.split("/")
-      if (scopeParts.length >= 2) {
-        const scopedName = `${scopeParts[0]}/${scopeParts[1]}`
-        preSuppliedImports[scopedName] =
-          preSuppliedImports[resolvedNodeModulePath]
-      }
-    }
-  }
-}