@tscircuit/eval 0.0.362 → 0.0.364

package/lib/runner/CircuitRunner.ts

@@ -1,201 +0,0 @@
-import type { AnyCircuitElement } from "circuit-json"
-import type {
-  CircuitRunnerApi,
-  CircuitRunnerConfiguration,
-} from "lib/shared/types"
-import type { PlatformConfig } from "@tscircuit/props"
-import { createExecutionContext } from "../../webworker/execution-context"
-import { normalizeFsMap } from "./normalizeFsMap"
-import type { RootCircuit } from "@tscircuit/core"
-import * as React from "react"
-import { importEvalPath } from "webworker/import-eval-path"
-import { setupDefaultEntrypointIfNeeded } from "./setupDefaultEntrypointIfNeeded"
-import Debug from "debug"
-
-const debug = Debug("tsci:eval:CircuitRunner")
-
-export class CircuitRunner implements CircuitRunnerApi {
-  _executionContext: ReturnType<typeof createExecutionContext> | null = null
-  _circuitRunnerConfiguration: CircuitRunnerConfiguration = {
-    snippetsApiBaseUrl: "https://registry-api.tscircuit.com",
-    cjsRegistryUrl: "https://cjs.tscircuit.com",
-    verbose: false,
-  }
-  _eventListeners: Record<string, ((...args: any[]) => void)[]> = {}
-  _debugNamespace: string | undefined
-
-  constructor(configuration: Partial<CircuitRunnerConfiguration> = {}) {
-    Object.assign(this._circuitRunnerConfiguration, configuration)
-  }
-
-  async version(): Promise<string> {
-    return "0.0.0"
-  }
-
-  async executeWithFsMap(ogOpts: {
-    entrypoint?: string
-    mainComponentPath?: string
-    mainComponentName?: string
-    fsMap: Record<string, string>
-    name?: string
-    mainComponentProps?: Record<string, any>
-  }): Promise<void> {
-    const opts = { ...ogOpts }
-
-    if (this._circuitRunnerConfiguration.verbose) {
-      Debug.enable("tsci:eval:*")
-    }
-
-    debug("executeWithFsMap called with:", {
-      entrypoint: opts.entrypoint,
-      fsMapKeys: Object.keys(opts.fsMap),
-      name: opts.name,
-    })
-
-    setupDefaultEntrypointIfNeeded(opts)
-
-    debug("entrypoint after setupDefaultEntrypointIfNeeded:", {
-      entrypoint: opts.entrypoint,
-    })
-
-    this._executionContext = createExecutionContext(
-      this._circuitRunnerConfiguration,
-      {
-        name: opts.name,
-        platform: this._circuitRunnerConfiguration.platform,
-        projectConfig: this._circuitRunnerConfiguration.projectConfig,
-        debugNamespace: this._debugNamespace,
-      },
-    )
-    this._bindEventListeners(this._executionContext.circuit)
-
-    this._executionContext.fsMap = normalizeFsMap(opts.fsMap)
-    if (!this._executionContext.fsMap[opts.entrypoint!]) {
-      throw new Error(`Entrypoint "${opts.entrypoint}" not found`)
-    }
-    ;(globalThis as any).__tscircuit_circuit = this._executionContext.circuit
-
-    const entrypoint = opts.entrypoint!.startsWith("./")
-      ? opts.entrypoint
-      : `./${opts.entrypoint}`
-
-    debug("final entrypoint:", entrypoint)
-    await importEvalPath(entrypoint!, this._executionContext)
-  }
-
-  async execute(code: string, opts: { name?: string } = {}) {
-    if (this._circuitRunnerConfiguration.verbose) {
-      console.log(
-        "[CircuitRunner] execute called with code length:",
-        code.length,
-      )
-    }
-
-    this._executionContext = createExecutionContext(
-      this._circuitRunnerConfiguration,
-      {
-        ...opts,
-        platform: this._circuitRunnerConfiguration.platform,
-        projectConfig: this._circuitRunnerConfiguration.projectConfig,
-        debugNamespace: this._debugNamespace,
-      },
-    )
-    this._bindEventListeners(this._executionContext.circuit)
-    this._executionContext.fsMap["entrypoint.tsx"] = code
-    ;(globalThis as any).__tscircuit_circuit = this._executionContext.circuit
-
-    await importEvalPath("./entrypoint.tsx", this._executionContext)
-  }
-
-  async executeComponent(component: any, opts: { name?: string } = {}) {
-    if (this._circuitRunnerConfiguration.verbose) {
-      console.log("[CircuitRunner] executeComponent called")
-    }
-
-    this._executionContext = createExecutionContext(
-      this._circuitRunnerConfiguration,
-      {
-        ...opts,
-        platform: this._circuitRunnerConfiguration.platform,
-        projectConfig: this._circuitRunnerConfiguration.projectConfig,
-        debugNamespace: this._debugNamespace,
-      },
-    )
-    this._bindEventListeners(this._executionContext.circuit)
-    ;(globalThis as any).__tscircuit_circuit = this._executionContext.circuit
-
-    const element = typeof component === "function" ? component() : component
-    this._executionContext.circuit.add(element as any)
-  }
-
-  on(event: string, callback: (...args: any[]) => void) {
-    this._eventListeners[event] ??= []
-    this._eventListeners[event].push(callback)
-    this._executionContext?.circuit.on(event as any, callback)
-  }
-
-  async renderUntilSettled(): Promise<void> {
-    if (!this._executionContext) {
-      throw new Error("No circuit has been created")
-    }
-    await this._executionContext.circuit.renderUntilSettled()
-  }
-
-  async getCircuitJson(): Promise<AnyCircuitElement[]> {
-    if (!this._executionContext) {
-      throw new Error("No circuit has been created")
-    }
-    return this._executionContext.circuit.getCircuitJson()
-  }
-
-  clearEventListeners() {
-    if (this._executionContext?.circuit) {
-      for (const event in this._eventListeners) {
-        for (const listener of this._eventListeners[event]) {
-          const circuit = this._executionContext.circuit as unknown as {
-            // biome-ignore lint/complexity/noBannedTypes: <explanation>
-            removeListener?: (event: string, listener: Function) => void
-          }
-          circuit.removeListener?.(event, listener)
-        }
-      }
-    }
-
-    for (const event in this._eventListeners) {
-      delete this._eventListeners[event]
-    }
-  }
-
-  async kill() {
-    // Cleanup resources
-    this._executionContext = null
-  }
-
-  async setSnippetsApiBaseUrl(baseUrl: string) {
-    this._circuitRunnerConfiguration.snippetsApiBaseUrl = baseUrl
-  }
-
-  async setPlatformConfig(platform: PlatformConfig) {
-    this._circuitRunnerConfiguration.platform = platform
-  }
-
-  async setProjectConfig(project: Partial<PlatformConfig>) {
-    this._circuitRunnerConfiguration.projectConfig = project
-  }
-
-  async enableDebug(namespace: string) {
-    this._debugNamespace = namespace
-    if (this._executionContext) {
-      const circuit = this._executionContext.circuit as any
-      circuit.enableDebug?.(namespace)
-    }
-  }
-
-  private _bindEventListeners(circuit: RootCircuit) {
-    for (const event in this._eventListeners) {
-      for (const listener of this._eventListeners[event]) {
-        circuit.on(event as any, listener as any)
-      }
-    }
-  }
-}

package/lib/runner/index.ts

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

package/lib/runner/normalizeFsMap.ts

@@ -1,20 +0,0 @@
-export function normalizeFilePath(filePath: string) {
-  let normFilePath = filePath
-  normFilePath = normFilePath.replace(/\\/g, "/")
-  normFilePath = normFilePath.trim()
-  if (normFilePath.startsWith("./")) {
-    normFilePath = normFilePath.slice(2)
-  }
-  if (normFilePath.startsWith("/")) {
-    normFilePath = normFilePath.slice(1)
-  }
-  return normFilePath
-}
-
-export function normalizeFsMap(fsMap: Record<string, string>) {
-  const normalizedFsMap: Record<string, string> = {}
-  for (const [fsPath, fileContent] of Object.entries(fsMap)) {
-    normalizedFsMap[normalizeFilePath(fsPath)] = fileContent
-  }
-  return normalizedFsMap
-}

package/lib/runner/resolveFilePath.ts

@@ -1,90 +0,0 @@
-import { normalizeFilePath } from "./normalizeFsMap"
-import { dirname } from "lib/utils/dirname"
-
-function resolveRelativePath(importPath: string, cwd: string): string {
-  // Handle parent directory navigation
-  if (importPath.startsWith("../")) {
-    const parentDir = dirname(cwd)
-    return resolveRelativePath(importPath.slice(3), parentDir)
-  }
-  // Handle current directory
-  if (importPath.startsWith("./")) {
-    return resolveRelativePath(importPath.slice(2), cwd)
-  }
-  // Handle absolute path
-  if (importPath.startsWith("/")) {
-    return importPath.slice(1)
-  }
-  // Handle relative path
-  return `${cwd}/${importPath}`
-}
-
-export const resolveFilePath = (
-  unknownFilePath: string,
-  fsMapOrAllFilePaths: Record<string, string> | string[],
-  cwd?: string,
-) => {
-  // Handle parent directory navigation properly
-  const resolvedPath = cwd
-    ? resolveRelativePath(unknownFilePath, cwd)
-    : unknownFilePath
-
-  const filePaths = new Set(
-    Array.isArray(fsMapOrAllFilePaths)
-      ? fsMapOrAllFilePaths
-      : Object.keys(fsMapOrAllFilePaths),
-  )
-
-  if (filePaths.has(resolvedPath)) {
-    return resolvedPath
-  }
-
-  const normalizedFilePathMap = new Map<string, string>()
-  for (const filePath of filePaths) {
-    normalizedFilePathMap.set(normalizeFilePath(filePath), filePath)
-  }
-
-  const normalizedResolvedPath = normalizeFilePath(resolvedPath)
-
-  if (normalizedFilePathMap.has(normalizedResolvedPath)) {
-    return normalizedFilePathMap.get(normalizedResolvedPath)!
-  }
-
-  // Search for file with a set of different extensions
-  const extension = ["tsx", "ts", "json", "js", "jsx", "obj", "gltf", "glb"]
-  for (const ext of extension) {
-    const possibleFilePath = `${normalizedResolvedPath}.${ext}`
-    if (normalizedFilePathMap.has(possibleFilePath)) {
-      return normalizedFilePathMap.get(possibleFilePath)!
-    }
-  }
-
-  // Check if it's an absolute import
-  if (!unknownFilePath.startsWith("./") && !unknownFilePath.startsWith("../")) {
-    const normalizedUnknownFilePath = normalizeFilePath(unknownFilePath)
-    if (normalizedFilePathMap.has(normalizedUnknownFilePath)) {
-      return normalizedFilePathMap.get(normalizedUnknownFilePath)!
-    }
-    for (const ext of extension) {
-      const possibleFilePath = `${normalizedUnknownFilePath}.${ext}`
-      if (normalizedFilePathMap.has(possibleFilePath)) {
-        return normalizedFilePathMap.get(possibleFilePath)!
-      }
-    }
-  }
-
-  return null
-}
-
-export const resolveFilePathOrThrow = (
-  unknownFilePath: string,
-  fsMapOrAllFilePaths: Record<string, string> | string[],
-) => {
-  const resolvedFilePath = resolveFilePath(unknownFilePath, fsMapOrAllFilePaths)
-  if (!resolvedFilePath) {
-    throw new Error(
-      `File not found "${unknownFilePath}", available paths:\n\n${Object.keys(fsMapOrAllFilePaths).join(", ")}`,
-    )
-  }
-  return resolvedFilePath
-}

package/lib/runner/runTscircuitCode.ts

@@ -1,30 +0,0 @@
-import { CircuitRunner } from "./CircuitRunner"
-
-export async function runTscircuitCode(
-  filesystemOrCodeString: Record<string, string> | string,
-  opts?: Omit<Parameters<CircuitRunner["executeWithFsMap"]>[0], "fsMap">,
-) {
-  if (
-    typeof filesystemOrCodeString === "string" &&
-    !filesystemOrCodeString.includes("export")
-  ) {
-    throw new Error(
-      `The "export" keyword wasn't found in your provided code. You need to export a component in your code, e.g.\n\nexport default () => (\n  <resistor name="R1" resistance="1k" />\n)`,
-    )
-  }
-  const filesystem =
-    typeof filesystemOrCodeString === "string"
-      ? { "user-code.tsx": filesystemOrCodeString }
-      : filesystemOrCodeString
-
-  const circuitRunner = new CircuitRunner()
-
-  await circuitRunner.executeWithFsMap({
-    fsMap: filesystem,
-    ...opts,
-  })
-
-  await circuitRunner.renderUntilSettled()
-
-  return await circuitRunner.getCircuitJson()
-}

package/lib/runner/runTscircuitModule.ts

@@ -1,37 +0,0 @@
-import { runTscircuitCode } from "./runTscircuitCode"
-
-export const runTscircuitModule = async (
-  module: string,
-  opts: { props?: Record<string, any>; exportName?: string } = {},
-) => {
-  if (!module.startsWith("@")) {
-    module = `@tsci/${module.replace(/\//, ".")}`
-  }
-  const circuitJson = await runTscircuitCode(
-    {
-      // TODO handle exports that are not the default export by scanning
-      // otherExports for components
-      "user-code.tsx": `
-    import Module, * as otherExports from "${module}";
-
-    let exportName = "${opts.exportName ?? ""}"
-
-    if ((!Module || typeof Module !== "function") && !Boolean(exportName)) {
-      exportName = Object.keys(otherExports).filter(key => key[0] === key[0].toUpperCase() && typeof otherExports[key] === "function")[0]
-    }
-
-    const defaultExport = exportName ? otherExports[exportName] : Module
-
-    if (!defaultExport) {
-      throw new Error(\`No export found for module "\${module}" (tried "\${exportName ?? "default"}")\`)
-    }
-
-    export default defaultExport;
-    `,
-    },
-    {
-      mainComponentProps: opts.props,
-    },
-  )
-  return circuitJson
-}

package/lib/runner/setupDefaultEntrypointIfNeeded.ts

@@ -1,81 +0,0 @@
-import { resolveFilePathOrThrow } from "./resolveFilePath"
-import Debug from "debug"
-
-const debug = Debug("tsci:eval:setupDefaultEntrypointIfNeeded")
-
-export const setupDefaultEntrypointIfNeeded = (opts: {
-  entrypoint?: string
-  fsMap: Record<string, string>
-  mainComponentPath?: string
-  mainComponentName?: string
-  name?: string
-  mainComponentProps?: Record<string, any>
-}) => {
-  if (!opts.entrypoint && !opts.mainComponentPath) {
-    if ("index.tsx" in opts.fsMap) {
-      opts.mainComponentPath = "index.tsx"
-    } else if ("index.ts" in opts.fsMap) {
-      opts.mainComponentPath = "index.ts"
-    } else if (
-      Object.keys(opts.fsMap).filter((k) => k.endsWith(".tsx")).length === 1
-    ) {
-      opts.mainComponentPath = Object.keys(opts.fsMap)[0]
-    } else if ("tscircuit.config.json" in opts.fsMap) {
-      const configContent = opts.fsMap["tscircuit.config.json"]
-      try {
-        const config = JSON.parse(configContent)
-        if (config.mainEntrypoint) {
-          opts.entrypoint = config.mainEntrypoint
-        }
-      } catch (e) {
-        console.warn("Failed to parse tscircuit.config.json:", e)
-      }
-    } else {
-      throw new Error(
-        "Either entrypoint or mainComponentPath must be provided (no index file, could not infer entrypoint)",
-      )
-    }
-  }
-
-  if (!opts.entrypoint && opts.mainComponentPath) {
-    opts.entrypoint = "entrypoint.tsx"
-    const mainComponentCode =
-      opts.fsMap[resolveFilePathOrThrow(opts.mainComponentPath, opts.fsMap)]
-    if (!mainComponentCode) {
-      throw new Error(
-        `Main component path "${opts.mainComponentPath}" not found in fsMap. Available paths: ${Object.keys(opts.fsMap).join(", ")}`,
-      )
-    }
-    opts.fsMap[opts.entrypoint] = `
-     import * as UserComponents from "./${opts.mainComponentPath}";
-          
-      ${
-        opts.mainComponentName
-          ? `
-        const ComponentToRender = UserComponents["${opts.mainComponentName}"]
-        `
-          : `const ComponentToRender = UserComponents.default || 
-          Object.entries(UserComponents)
-          .filter(([name]) => !name.startsWith("use"))
-          .map(([_, component]) => component)[0] || (() => null);`
-      }
-
-           ${
-             debug.enabled
-               ? `
-     console.log({ UserComponents })
-     console.log("ComponentToRender " + ComponentToRender.toString(),  { ComponentToRender })
-     `
-               : ""
-           }
-
-      circuit.add(       
-          <ComponentToRender ${opts.mainComponentProps ? `{...${JSON.stringify(opts.mainComponentProps, null, 2)}}` : ""} /> 
-      );
-`
-  }
-
-  if (!opts.name && opts.mainComponentName) {
-    opts.name = opts.mainComponentName
-  }
-}

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

@@ -1,10 +0,0 @@
-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/lib/shared/types.ts

@@ -1,79 +0,0 @@
-import type { AnyCircuitElement } from "circuit-json"
-import type { RootCircuitEventName as CoreRootCircuitEventName } from "@tscircuit/core"
-import type { PlatformConfig } from "@tscircuit/props"
-
-export type RootCircuitEventName = CoreRootCircuitEventName | "debug:logOutput"
-
-export interface CircuitRunnerConfiguration {
-  snippetsApiBaseUrl: string
-  cjsRegistryUrl: string
-  verbose?: boolean
-  platform?: PlatformConfig
-  projectConfig?: Partial<PlatformConfig>
-}
-
-export interface WebWorkerConfiguration extends CircuitRunnerConfiguration {
-  evalVersion?: string
-  /**
-   * @deprecated, renamed to webWorkerBlobUrl
-   */
-  webWorkerUrl?: URL | string
-  webWorkerBlobUrl?: URL | string
-  /**
-   * Enable fetch proxy to route worker fetch requests through parent thread.
-   * Useful when running in restricted environments (like ChatGPT) where
-   * worker fetch requests are blocked.
-   * Default: false
-   */
-  enableFetchProxy?: boolean
-}
-
-/**
- * API for the CircuitRunner class, used for eval'ing circuits
- */
-export interface CircuitRunnerApi {
-  version: () => Promise<string>
-  execute: (
-    code: string,
-    opts?: {
-      name?: string
-    },
-  ) => Promise<void>
-  executeComponent: (component: any) => Promise<void>
-  executeWithFsMap(opts: {
-    entrypoint?: string
-    fsMap: Record<string, string>
-    name?: string
-  }): Promise<void>
-  renderUntilSettled: () => Promise<void>
-  getCircuitJson: () => Promise<AnyCircuitElement[]>
-  setSnippetsApiBaseUrl: (baseUrl: string) => Promise<void>
-  setPlatformConfig: (platform: PlatformConfig) => Promise<void>
-  setProjectConfig: (project: Partial<PlatformConfig>) => Promise<void>
-  enableDebug: (namespace: string) => Promise<void>
-  on: (event: RootCircuitEventName, callback: (...args: any[]) => void) => void
-  clearEventListeners: () => void
-  kill: () => Promise<void>
-}
-
-/**
- * @deprecated, use CircuitRunnerApi instead
- */
-export type InternalWebWorkerApi = CircuitRunnerApi
-
-export type CircuitWebWorker = {
-  execute: (code: string) => Promise<void>
-  executeComponent: (component: any) => Promise<void>
-  executeWithFsMap: (opts: {
-    entrypoint?: string
-    mainComponentPath?: string
-    fsMap: Record<string, string>
-  }) => Promise<void>
-  renderUntilSettled: () => Promise<void>
-  getCircuitJson: () => Promise<AnyCircuitElement[]>
-  on: (event: RootCircuitEventName, callback: (...args: any[]) => void) => void
-  clearEventListeners: () => void
-  enableDebug: (namespace: string) => Promise<void>
-  version: () => Promise<string>
-  kill: () => Promise<void>
-}

package/lib/utils/dirname.ts

@@ -1,21 +0,0 @@
-/**
- * Returns the directory name of a path, similar to Node.js path.dirname
- * Works on both Unix and Windows paths
- * @param path The path to extract the directory from
- * @returns The directory part of the path
- */
-export function dirname(path: string): string {
-  if (!path) return "."
-
-  // Normalize path separators to forward slashes
-  const normalizedPath = path.replace(/\\/g, "/")
-
-  // Remove trailing slashes
-  const cleanPath = normalizedPath.replace(/\/+$/, "")
-
-  // If there are no slashes, return "."
-  if (cleanPath.indexOf("/") === -1) return "."
-
-  // Return everything up to the last slash
-  return cleanPath.substring(0, cleanPath.lastIndexOf("/")) || "/"
-}

package/lib/utils/get-imports-from-code.ts

@@ -1,23 +0,0 @@
-export const getImportsFromCode = (code: string): string[] => {
-  // Match basic import patterns including combined default and namespace imports
-  const importRegex =
-    /^\s*import\s+(?:(?:[\w\s]+,\s*)?(?:\*\s+as\s+[\w\s]+|\{[\s\w,]+\}|\w+)\s+from\s*)?['"](.+?)['"]/gm
-  const imports: string[] = []
-  let match: RegExpExecArray | null
-
-  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
-  while ((match = importRegex.exec(code)) !== null) {
-    imports.push(match[1])
-  }
-
-  // Match re-exports
-  const reExportRegex =
-    /^\s*export\s+(?:\*|(?:\{[\s\w,]+\}))\s+from\s*['"](.+?)['"]/gm
-  let reExportMatch: RegExpExecArray | null
-  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
-  while ((reExportMatch = reExportRegex.exec(code)) !== null) {
-    imports.push(reExportMatch[1])
-  }
-
-  return imports
-}

package/lib/utils/index.ts

@@ -1 +0,0 @@
-export * from "./get-imports-from-code"