@tscircuit/eval 0.0.363 → 0.0.364

package/lib/utils/resolve-node-module.ts

@@ -1,193 +0,0 @@
-import { dirname } from "./dirname"
-
-interface PackageJson {
-  main?: string
-  module?: string
-  exports?: Record<string, string | Record<string, string>>
-}
-
-interface NodeResolutionContext {
-  fsMap: Record<string, string>
-  extensions: string[]
-  basePath: string
-  modulePath: string
-}
-
-function createContext(
-  modulePath: string,
-  fsMap: Record<string, string>,
-  basePath: string,
-): NodeResolutionContext {
-  return {
-    fsMap,
-    extensions: [".js", ".jsx", ".ts", ".tsx", ".json"],
-    basePath,
-    modulePath,
-  }
-}
-
-function findPackageJson(nodeModulesPath: string, ctx: NodeResolutionContext) {
-  const packageJsonPath = `${nodeModulesPath}/package.json`
-  if (!ctx.fsMap[packageJsonPath]) return null
-  try {
-    return JSON.parse(ctx.fsMap[packageJsonPath]) as PackageJson
-  } catch {
-    return null
-  }
-}
-
-function tryResolveWithExtensions(
-  path: string,
-  ctx: NodeResolutionContext,
-): string | null {
-  if (ctx.fsMap[path]) return path
-
-  for (const ext of ctx.extensions) {
-    const pathWithExt = path.replace(/\.js$|\.jsx$/, "") + ext
-    if (ctx.fsMap[pathWithExt]) return pathWithExt
-  }
-  return null
-}
-
-function resolveExportPath(
-  nodeModulesPath: string,
-  exportPath: string,
-  ctx: NodeResolutionContext,
-): string | null {
-  const fullExportPath = `${nodeModulesPath}/${exportPath.replace(/^\.\//, "")}`
-  return tryResolveWithExtensions(fullExportPath, ctx)
-}
-
-function resolvePackageExports(
-  nodeModulesPath: string,
-  packageJson: PackageJson,
-  remainingPath: string,
-  ctx: NodeResolutionContext,
-): string | null {
-  if (!packageJson.exports) return null
-
-  // Handle default export condition
-  const defaultExport = packageJson.exports["."]
-  if (remainingPath === "" && defaultExport) {
-    if (typeof defaultExport === "string") {
-      const resolved = resolveExportPath(nodeModulesPath, defaultExport, ctx)
-      if (resolved) return resolved
-    }
-  }
-
-  // Handle subpath exports
-  const subpathExport = remainingPath
-    ? packageJson.exports[`./${remainingPath}`]
-    : null
-  if (subpathExport && typeof subpathExport === "string") {
-    const resolved = resolveExportPath(nodeModulesPath, subpathExport, ctx)
-    if (resolved) return resolved
-  }
-
-  // Handle conditional exports
-  const importExport = packageJson.exports["import"]
-  if (
-    remainingPath === "" &&
-    importExport &&
-    typeof importExport === "string"
-  ) {
-    const resolved = resolveExportPath(nodeModulesPath, importExport, ctx)
-    if (resolved) return resolved
-  }
-
-  return null
-}
-
-function resolvePackageEntryPoint(
-  nodeModulesPath: string,
-  packageJson: PackageJson,
-  ctx: NodeResolutionContext,
-): string | null {
-  const entryPoint = packageJson.module || packageJson.main || "index.js"
-  const fullPath = `${nodeModulesPath}/${entryPoint}`
-  return tryResolveWithExtensions(fullPath, ctx)
-}
-
-function resolveRemainingPath(
-  nodeModulesPath: string,
-  remainingPath: string,
-  ctx: NodeResolutionContext,
-): string | null {
-  if (!remainingPath) {
-    // Try index files in the module root
-    for (const ext of ctx.extensions) {
-      const indexPath = `${nodeModulesPath}/index${ext}`
-      if (ctx.fsMap[indexPath]) return indexPath
-    }
-    return null
-  }
-
-  const fullPath = `${nodeModulesPath}/${remainingPath}`
-  const directMatch = tryResolveWithExtensions(fullPath, ctx)
-  if (directMatch) return directMatch
-
-  // Try index files
-  for (const ext of ctx.extensions) {
-    const indexPath = `${fullPath}/index${ext}`
-    if (ctx.fsMap[indexPath]) return indexPath
-  }
-  return null
-}
-
-function resolveNodeModuleInPath(
-  searchPath: string,
-  ctx: NodeResolutionContext,
-): string | null {
-  const moduleParts = ctx.modulePath.split("/")
-  const scope = moduleParts[0].startsWith("@")
-    ? moduleParts.slice(0, 2).join("/")
-    : moduleParts[0]
-  const remainingPath = moduleParts.slice(scope.includes("/") ? 2 : 1).join("/")
-  const nodeModulesPath = `${searchPath == "." ? "" : `${searchPath}/`}node_modules/${scope}`
-
-  // Try to find package.json
-  const packageJson = findPackageJson(nodeModulesPath, ctx)
-  if (packageJson) {
-    // Try resolving through exports field
-    const exportsResolution = resolvePackageExports(
-      nodeModulesPath,
-      packageJson,
-      remainingPath,
-      ctx,
-    )
-    if (exportsResolution) return exportsResolution
-
-    // Try resolving through main/module fields
-    const entryPointResolution = resolvePackageEntryPoint(
-      nodeModulesPath,
-      packageJson,
-      ctx,
-    )
-    if (entryPointResolution) return entryPointResolution
-  }
-
-  // Try resolving remaining path
-  const remainingPathResolution = resolveRemainingPath(
-    nodeModulesPath,
-    remainingPath,
-    ctx,
-  )
-  if (remainingPathResolution) return remainingPathResolution
-
-  // If not found and we have a parent directory, try there
-  const parentPath = dirname(searchPath)
-  if (parentPath && parentPath !== searchPath) {
-    return resolveNodeModuleInPath(parentPath, ctx)
-  }
-
-  return null
-}
-
-export function resolveNodeModule(
-  modulePath: string,
-  fsMap: Record<string, string>,
-  basePath: string,
-): string | null {
-  const ctx = createContext(modulePath, fsMap, basePath)
-  return resolveNodeModuleInPath(ctx.basePath, ctx)
-}

package/lib/worker.ts

@@ -1,246 +0,0 @@
-import * as Comlink from "comlink"
-export * from "./utils/index"
-import type {
-  InternalWebWorkerApi,
-  WebWorkerConfiguration,
-  CircuitWebWorker,
-} from "./shared/types"
-import type { RootCircuitEventName } from "./shared/types"
-
-export type { CircuitWebWorker, WebWorkerConfiguration }
-
-declare global {
-  interface Window {
-    TSCIRCUIT_GLOBAL_CIRCUIT_WORKER: CircuitWebWorker | undefined
-  }
-  var TSCIRCUIT_GLOBAL_CIRCUIT_WORKER: CircuitWebWorker | undefined
-}
-
-export const createCircuitWebWorker = async (
-  configuration: Partial<WebWorkerConfiguration>,
-): Promise<CircuitWebWorker> => {
-  // Kill existing global worker instance if present
-  const existingWorker = globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER
-  if (existingWorker && typeof existingWorker.kill === "function") {
-    if (configuration.verbose) {
-      console.log("[Worker] Killing previous global worker instance...")
-    }
-    try {
-      await existingWorker.kill()
-    } catch (e) {
-      if (configuration.verbose) {
-        console.warn(
-          "[Worker] Error killing previous global worker instance:",
-          e,
-        )
-      }
-      // Ensure the key is cleared even if kill throws an error
-      if (globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER === existingWorker) {
-        globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = undefined
-      }
-    }
-  }
-
-  if (configuration.verbose) {
-    console.log(
-      "[Worker] Creating circuit web worker with config:",
-      configuration,
-    )
-  }
-
-  let workerBlobUrl =
-    configuration.webWorkerBlobUrl ?? configuration.webWorkerUrl
-
-  if (!workerBlobUrl) {
-    const cdnUrl = `https://cdn.jsdelivr.net/npm/@tscircuit/eval@${configuration.evalVersion ?? "latest"}/dist/webworker/entrypoint.js`
-
-    const workerBlob = await globalThis.fetch(cdnUrl).then((res) => res.blob())
-    workerBlobUrl = URL.createObjectURL(workerBlob)
-  }
-
-  const rawWorker = new Worker(workerBlobUrl, { type: "module" })
-  let workerInitError: any
-  rawWorker.addEventListener("error", (event) => {
-    console.error("[Worker] Error in worker", event)
-    workerInitError = event
-  })
-  rawWorker.addEventListener("unhandledrejection", (event) => {
-    console.error("[Worker] Unhandled rejection in worker", event)
-  })
-  rawWorker.addEventListener("messageerror", (event) => {
-    console.error("[Worker] Message error in worker", event)
-  })
-  const earlyMessageHandler = (event: MessageEvent) => {
-    console.log("[Worker] Message in worker", event)
-  }
-  rawWorker.addEventListener("message", earlyMessageHandler)
-
-  // Handle fetch requests from the worker
-  rawWorker.addEventListener("message", async (event: MessageEvent) => {
-    const data = event.data
-    if (data?.type !== "worker_fetch") return
-
-    try {
-      const response = await globalThis.fetch(data.input, data.init)
-      const body = await response.text()
-      rawWorker.postMessage({
-        type: "worker_fetch_result",
-        requestId: data.requestId,
-        success: true,
-        response: {
-          body,
-          status: response.status,
-          statusText: response.statusText,
-          headers: (() => {
-            const obj: Record<string, string> = {}
-            response.headers.forEach((value, key) => {
-              obj[key] = value
-            })
-            return obj
-          })(),
-        },
-      })
-    } catch (err: any) {
-      rawWorker.postMessage({
-        type: "worker_fetch_result",
-        requestId: data.requestId,
-        success: false,
-        error: {
-          name: err.name,
-          message: err.message,
-          stack: err.stack,
-        },
-      })
-    }
-  })
-
-  if (workerInitError) {
-    throw workerInitError
-  }
-
-  const comlinkWorker = Comlink.wrap<InternalWebWorkerApi>(rawWorker)
-
-  rawWorker.removeEventListener("message", earlyMessageHandler)
-
-  // Helper to serialize React elements for cross-worker communication
-  function serializeReactElement(element: any): any {
-    if (!element || typeof element !== "object") {
-      return element
-    }
-
-    if (element.type && element.props !== undefined) {
-      // This is a React element
-      return {
-        __isSerializedReactElement: true,
-        type: element.type,
-        props: serializeProps(element.props),
-        key: element.key,
-      }
-    }
-
-    return element
-  }
-
-  function serializeProps(props: any): any {
-    if (!props || typeof props !== "object") {
-      return props
-    }
-
-    const serialized: any = {}
-    for (const [key, value] of Object.entries(props)) {
-      if (key === "children") {
-        if (Array.isArray(value)) {
-          serialized.children = value.map(serializeReactElement)
-        } else {
-          serialized.children = serializeReactElement(value)
-        }
-      } else {
-        serialized[key] = value
-      }
-    }
-    return serialized
-  }
-
-  // Conditionally override global fetch inside the worker to route through the parent
-  // Only enable when explicitly requested via configuration
-  if (configuration.enableFetchProxy) {
-    rawWorker.postMessage({ type: "override_global_fetch" })
-  }
-
-  if (configuration.snippetsApiBaseUrl) {
-    await comlinkWorker.setSnippetsApiBaseUrl(configuration.snippetsApiBaseUrl)
-  }
-  if (configuration.platform) {
-    await comlinkWorker.setPlatformConfig(configuration.platform)
-  }
-  if (configuration.projectConfig) {
-    await comlinkWorker.setProjectConfig(configuration.projectConfig)
-  }
-
-  let isTerminated = false
-
-  // Create a wrapper that handles events directly through circuit instance
-  const wrapper: CircuitWebWorker = {
-    clearEventListeners: comlinkWorker.clearEventListeners.bind(comlinkWorker),
-    enableDebug: async (...args) => {
-      if (isTerminated) {
-        throw new Error("CircuitWebWorker was terminated, can't enableDebug")
-      }
-      return comlinkWorker.enableDebug.bind(comlinkWorker)(...args)
-    },
-    version: comlinkWorker.version.bind(comlinkWorker),
-    execute: async (...args) => {
-      if (isTerminated) {
-        throw new Error("CircuitWebWorker was terminated, can't execute")
-      }
-      return comlinkWorker.execute.bind(comlinkWorker)(...args)
-    },
-    executeComponent: async (component: any) => {
-      if (isTerminated) {
-        throw new Error(
-          "CircuitWebWorker was terminated, can't executeComponent",
-        )
-      }
-
-      // If it's a function, pass it as-is (will be proxied by Comlink)
-      if (typeof component === "function") {
-        return comlinkWorker.executeComponent.bind(comlinkWorker)(component)
-      }
-
-      // If it's a React element, serialize it to a reconstructable format
-      if (component && typeof component === "object" && component.type) {
-        const serializedElement = serializeReactElement(component)
-        return comlinkWorker.executeComponent.bind(comlinkWorker)(
-          serializedElement,
-        )
-      }
-
-      return comlinkWorker.executeComponent.bind(comlinkWorker)(component)
-    },
-    executeWithFsMap: async (...args) => {
-      if (isTerminated) {
-        throw new Error(
-          "CircuitWebWorker was terminated, can't executeWithFsMap",
-        )
-      }
-      return comlinkWorker.executeWithFsMap.bind(comlinkWorker)(...args)
-    },
-    renderUntilSettled: comlinkWorker.renderUntilSettled.bind(comlinkWorker),
-    getCircuitJson: comlinkWorker.getCircuitJson.bind(comlinkWorker),
-    on: (event: string, callback: (...args: any[]) => void) => {
-      const proxiedCallback = Comlink.proxy(callback)
-      comlinkWorker.on(event as RootCircuitEventName, proxiedCallback)
-    },
-    kill: async () => {
-      comlinkWorker[Comlink.releaseProxy]()
-      rawWorker.terminate()
-      isTerminated = true
-      if (globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER === wrapper) {
-        globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = undefined
-      }
-    },
-  }
-  ;(wrapper as any).__rawWorker = rawWorker
-  globalThis.TSCIRCUIT_GLOBAL_CIRCUIT_WORKER = wrapper
-  return wrapper
-}

package/playwright.config.ts

@@ -1,23 +0,0 @@
-import { defineConfig } from "@playwright/test"
-
-export default defineConfig({
-  testDir: "./browser-tests",
-  timeout: 30000,
-  expect: {
-    timeout: 5000,
-  },
-  fullyParallel: true,
-  forbidOnly: !!process.env.CI,
-  retries: process.env.CI ? 2 : 0,
-  workers: process.env.CI ? 1 : undefined,
-  reporter: "html",
-  use: {
-    actionTimeout: 0,
-    trace: "on-first-retry",
-  },
-  webServer: {
-    command: "bun run start:browser-test-server",
-    port: 3070,
-    reuseExistingServer: !process.env.CI,
-  },
-})

package/scripts/build-worker-blob-url.ts

@@ -1,27 +0,0 @@
-import { readFileSync, writeFileSync } from "node:fs"
-
-function createWorkerBlobCode(jsCode: string) {
-  // Convert the code to Base64 to avoid issues with special characters and newlines
-  const encodedCode = Buffer.from(jsCode).toString("base64")
-
-  // Create code that will construct a Blob URL from the Base64-encoded JavaScript
-  const blobCode = `
-    const decodedCode = atob("${encodedCode}")
-    const blob = new Blob([decodedCode], { type: "application/javascript" })
-    const blobUrl = URL.createObjectURL(blob)
-    export default blobUrl
-  `
-
-  return blobCode
-}
-
-// Generate the .d.ts file content
-const typeDefinition = `declare const blobUrl: string
-export default blobUrl
-`
-
-const workerCode = readFileSync("./dist/webworker/entrypoint.js", "utf-8")
-const blobConstructorCode = createWorkerBlobCode(workerCode)
-
-writeFileSync("./dist/blob-url.js", blobConstructorCode)
-writeFileSync("./dist/blob-url.d.ts", typeDefinition)

package/scripts/copy-core-versions.ts

@@ -1,81 +0,0 @@
-// @ts-ignore
-import corePackageJson from "@tscircuit/core/package.json"
-import currentPackageJson from "../package.json"
-import { join } from "node:path"
-
-const DONT_SYNC_FROM_CORE: string[] = []
-
-const coreDeps: any = {
-  ...corePackageJson.devDependencies,
-  ...corePackageJson.dependencies,
-}
-
-const currentDeps: any = { ...currentPackageJson.devDependencies }
-const depsToUpdate: any = {}
-
-let modifiedDeps = false
-
-// Update existing dependencies to match core
-for (const [packageName, currentVersion] of Object.entries(currentDeps)) {
-  if (packageName in coreDeps && coreDeps[packageName] !== currentVersion) {
-    console.log(
-      `Updating ${packageName} from ${currentVersion} to ${coreDeps[packageName]}`,
-    )
-    depsToUpdate[packageName] = coreDeps[packageName as keyof typeof coreDeps]
-    modifiedDeps = true
-  }
-}
-
-// Add new dependencies from core that we don't have yet
-for (const [packageName, version] of Object.entries(
-  corePackageJson.devDependencies || {},
-)) {
-  if (
-    !DONT_SYNC_FROM_CORE.includes(packageName) &&
-    !(packageName in currentDeps)
-  ) {
-    console.log(`Adding new dependency ${packageName}: ${version}`)
-    depsToUpdate[packageName] = version
-    modifiedDeps = true
-  }
-}
-
-if (modifiedDeps) {
-  // Use regex to replace the dependencies in the package.json
-  const packageJsonPath = join(import.meta.dirname, "../package.json")
-  let packageJson = await Bun.file(packageJsonPath).text()
-
-  // Update existing dependencies
-  for (const [packageName, version] of Object.entries(depsToUpdate)) {
-    if (packageName in currentDeps) {
-      const pattern = `"${packageName}":\\s*"${currentDeps[packageName].replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"(,)?`
-      packageJson = packageJson.replace(
-        new RegExp(pattern),
-        `"${packageName}": "${version}"$1`,
-      )
-    }
-  }
-
-  // Add new dependencies at the end of devDependencies
-  const newDeps = Object.entries(depsToUpdate).filter(
-    ([packageName]) => !(packageName in currentDeps),
-  )
-  if (newDeps.length > 0) {
-    // Find the last dependency in devDependencies and add after it
-    const devDepsPattern = /"devDependencies":\s*{([^}]+)}/
-    const match = packageJson.match(devDepsPattern)
-    if (match) {
-      const devDepsContent = match[1]
-      const newDepsStr = newDeps
-        .map(([name, version]) => `    "${name}": "${version}"`)
-        .join(",\n")
-      const updatedDevDeps = `${devDepsContent.trimEnd()},\n${newDepsStr}`
-      packageJson = packageJson.replace(
-        devDepsPattern,
-        `"devDependencies": {${updatedDevDeps}}`,
-      )
-    }
-  }
-
-  await Bun.write(packageJsonPath, packageJson)
-}