@ebowwa/sandbox 0.1.1

package/src/compilers/typescript.ts

@@ -0,0 +1,442 @@
+/**
+ * TypeScript Compiler for @ebowwa/sandbox
+ *
+ * Compiles TypeScript to WASM via JavaScript.
+ * Uses esbuild for fast TypeScript transpilation, then delegates to JavaScript compiler.
+ */
+
+import {
+  BaseCompiler,
+  type CompileResult,
+  type CompilerOptions,
+  type LanguageCapabilities,
+} from "../core/compiler.js";
+import type { Permissions, Limits } from "../core/types.js";
+import { JavaScriptCompiler, type JavaScriptCompilerOptions } from "./javascript.js";
+
+/** TypeScript compiler options */
+export interface TypeScriptCompilerOptions extends CompilerOptions {
+  /** TypeScript target */
+  target?: "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "esnext";
+  /** Module format */
+  module?: "esm" | "cjs" | "iife";
+  /** Enable strict type checking */
+  strict?: boolean;
+  /** Emit declaration files */
+  declaration?: boolean;
+  /** Source map generation */
+  sourceMap?: boolean;
+  /** JSX transform */
+  jsx?: "transform" | "preserve" | "automatic";
+  /** JSX factory */
+  jsxFactory?: string;
+  /** JSX fragment factory */
+  jsxFragment?: string;
+  /** Use AssemblyScript for compilation */
+  useAssemblyScript?: boolean;
+  /** Transpiler to use */
+  transpiler?: "esbuild" | "swc" | "tsc";
+}
+
+/** Transpilation result */
+interface TranspileResult {
+  code: string;
+  map?: string;
+  declarations?: string;
+}
+
+// Dynamic import type for esbuild (optional dependency)
+type EsbuildModule = {
+  transform: (input: string, options?: Record<string, unknown>) => Promise<{ code: string; map?: string }>;
+};
+
+// Dynamic import type for SWC (optional dependency)
+type SwcModule = {
+  transform: (code: string, options?: Record<string, unknown>) => Promise<{ code: string; map?: string }>;
+};
+
+/**
+ * TypeScript Compiler
+ *
+ * Transpiles TypeScript to JavaScript, then compiles to WASM.
+ * Supports both standard TypeScript and AssemblyScript syntax.
+ */
+export class TypeScriptCompiler extends BaseCompiler {
+  readonly language = "typescript" as const;
+
+  private jsCompiler: JavaScriptCompiler;
+  private esbuildAvailable: boolean | null = null;
+  private swcAvailable: boolean | null = null;
+
+  constructor() {
+    super();
+    this.jsCompiler = new JavaScriptCompiler();
+  }
+
+  /**
+   * Check if TypeScript compiler is available
+   */
+  async isAvailable(): Promise<boolean> {
+    // TypeScript compiler is always available (we have built-in support)
+    // But transpilers may vary
+    return true;
+  }
+
+  /**
+   * Validate TypeScript syntax
+   */
+  async validate(source: string): Promise<{ valid: boolean; error?: string }> {
+    try {
+      const transpiler = await this.getTranspiler("esbuild");
+
+      if (transpiler?.type === "esbuild") {
+        await transpiler.module.transform(source, {
+          loader: "ts",
+          target: "es2020",
+          tsconfigRaw: {
+            compilerOptions: {
+              strict: true,
+              noEmit: true,
+            },
+          },
+        });
+        return { valid: true };
+      }
+
+      // Fallback: basic regex check for common syntax errors
+      const syntaxErrors = this.checkBasicSyntax(source);
+      if (syntaxErrors) {
+        return { valid: false, error: syntaxErrors };
+      }
+
+      return { valid: true };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Compile TypeScript to WASM
+   *
+   * 1. Transpile TypeScript to JavaScript
+   * 2. Use JavaScript compiler for WASM compilation
+   */
+  async compile(
+    source: string,
+    permissions: Permissions,
+    limits: Limits,
+    options?: TypeScriptCompilerOptions
+  ): Promise<CompileResult> {
+    const opts: TypeScriptCompilerOptions = {
+      target: "es2020",
+      module: "esm",
+      strict: true,
+      declaration: false,
+      sourceMap: options?.sourceMap ?? false,
+      jsx: "transform",
+      jsxFactory: "React.createElement",
+      jsxFragment: "React.Fragment",
+      useAssemblyScript: false,
+      transpiler: "esbuild",
+      ...options,
+    };
+
+    // Check if source uses AssemblyScript types
+    const isAssemblyScript = this.detectAssemblyScript(source);
+    const effectiveUseAssemblyScript = opts.useAssemblyScript || isAssemblyScript;
+
+    // Transpile TypeScript to JavaScript
+    const transpiled = await this.transpile(source, {
+      ...opts,
+      useAssemblyScript: effectiveUseAssemblyScript,
+    });
+
+    // Delegate to JavaScript compiler
+    const jsOptions: JavaScriptCompilerOptions = {
+      target: opts.target,
+      module: opts.module,
+      strict: opts.strict,
+      useAssemblyScript: effectiveUseAssemblyScript,
+      optimize: opts.optimize,
+      debug: opts.debug,
+      sourceMap: opts.sourceMap,
+    };
+
+    const result = await this.jsCompiler.compile(
+      transpiled.code,
+      permissions,
+      limits,
+      jsOptions
+    );
+
+    // Include source map if generated
+    if (transpiled.map) {
+      result.sourceMap = transpiled.map;
+    }
+
+    return result;
+  }
+
+  /**
+   * Get language capabilities
+   */
+  getCapabilities(): LanguageCapabilities {
+    return {
+      repl: true,
+      stateful: true,
+      compiled: false, // TS transpiles to JS, which is interpreted
+      gc: true, // JavaScript has garbage collection
+      imports: true,
+      async: true,
+    };
+  }
+
+  /**
+   * Transpile TypeScript to JavaScript
+   */
+  private async transpile(
+    source: string,
+    options: TypeScriptCompilerOptions
+  ): Promise<TranspileResult> {
+    // If using AssemblyScript, don't transpile types
+    if (options.useAssemblyScript) {
+      return {
+        code: source,
+        map: undefined,
+      };
+    }
+
+    const transpiler = await this.getTranspiler(options.transpiler || "esbuild");
+
+    if (transpiler?.type === "esbuild") {
+      return this.transpileWithEsbuild(source, options, transpiler.module);
+    }
+
+    if (transpiler?.type === "swc") {
+      return this.transpileWithSwc(source, options, transpiler.module);
+    }
+
+    // Fallback: strip types using regex (not recommended for production)
+    return this.transpileWithRegex(source);
+  }
+
+  /**
+   * Transpile using esbuild
+   */
+  private async transpileWithEsbuild(
+    source: string,
+    options: TypeScriptCompilerOptions,
+    esbuild: EsbuildModule
+  ): Promise<TranspileResult> {
+    const result = await esbuild.transform(source, {
+      loader: "ts",
+      target: options.target || "es2020",
+      format: options.module === "cjs" ? "cjs" : "esm",
+      minify: options.optimize,
+      sourcemap: options.sourceMap ? "external" : false,
+      jsx: options.jsx === "automatic" ? "automatic" : "transform",
+      jsxFactory: options.jsxFactory,
+      jsxFragment: options.jsxFragment,
+      tsconfigRaw: {
+        compilerOptions: {
+          strict: options.strict,
+          target: options.target,
+          module: options.module?.toUpperCase(),
+          esModuleInterop: true,
+          allowSyntheticDefaultImports: true,
+          resolveJsonModule: true,
+          declaration: options.declaration,
+        },
+      },
+    });
+
+    return {
+      code: result.code,
+      map: result.map,
+    };
+  }
+
+  /**
+   * Transpile using SWC
+   */
+  private async transpileWithSwc(
+    source: string,
+    options: TypeScriptCompilerOptions,
+    swc: SwcModule
+  ): Promise<TranspileResult> {
+    const result = await swc.transform(source, {
+      jsc: {
+        parser: {
+          syntax: "typescript",
+          tsx: options.jsx !== "preserve",
+        },
+        transform: {
+          react: {
+            runtime: options.jsx === "automatic" ? "automatic" : "classic",
+            pragma: options.jsxFactory,
+            pragmaFrag: options.jsxFragment,
+          },
+        },
+        target: options.target?.replace("es", "es") || "es2020",
+      },
+      module: {
+        type: options.module === "cjs" ? "commonjs" : "es6",
+      },
+      minify: options.optimize,
+      sourceMaps: options.sourceMap,
+    });
+
+    return {
+      code: result.code,
+      map: result.map,
+    };
+  }
+
+  /**
+   * Fallback transpilation using regex (basic type stripping)
+   *
+   * Note: This is not a complete TypeScript implementation.
+   * Use esbuild or swc for production code.
+   */
+  private transpileWithRegex(source: string): TranspileResult {
+    let code = source;
+
+    // Strip type annotations
+    // This is a simplified implementation
+    const patterns = [
+      // Remove type annotations: : Type
+      /:\s*[A-Z][a-zA-Z0-9_]*(?:<[^>]+>)?(?:\[\])?(?:\s*\|\s*[A-Z][a-zA-Z0-9_]*(?:<[^>]+>)?(?:\[\])?)*/g,
+      // Remove interface declarations
+      /interface\s+[A-Z][a-zA-Z0-9_]*\s*(?:<[^>]+>)?\s*\{[^}]*\}/g,
+      // Remove type declarations
+      /type\s+[A-Z][a-zA-Z0-9_]*\s*(?:<[^>]+>)?\s*=\s*[^;]+;/g,
+      // Remove enum declarations (convert to const objects)
+      /enum\s+([A-Z][a-zA-Z0-9_]*)\s*\{([^}]*)\}/g,
+      // Remove generic type parameters
+      /<[^>]+>/g,
+      // Remove 'as' type assertions
+      /\s+as\s+[A-Z][a-zA-Z0-9_]*(?:<[^>]+>)?/g,
+      // Remove 'satisfies' type assertions
+      /\s+satisfies\s+[A-Z][a-zA-Z0-9_]*(?:<[^>]+>)?/g,
+      // Remove 'declare' statements
+      /declare\s+(?:const|let|var|function|class|interface|type|enum)\s+[^;]+;/g,
+      // Remove 'public', 'private', 'protected', 'readonly' modifiers
+      /\b(?:public|private|protected|readonly)\s+/g,
+      // Remove 'abstract' modifier
+      /\babstract\s+/g,
+      // Remove parameter properties in constructors
+      /constructor\s*\(([^)]*)\)/g,
+    ];
+
+    for (const pattern of patterns) {
+      code = code.replace(pattern, "");
+    }
+
+    return {
+      code,
+      map: undefined,
+    };
+  }
+
+  /**
+   * Get the best available transpiler
+   */
+  private async getTranspiler(
+    preferred: "esbuild" | "swc" | "tsc"
+  ): Promise<
+    | {
+        type: "esbuild";
+        module: EsbuildModule;
+      }
+    | {
+        type: "swc";
+        module: SwcModule;
+      }
+    | null
+  > {
+    if (preferred === "esbuild" || preferred === "tsc") {
+      if (this.esbuildAvailable === null) {
+        try {
+          await import("esbuild");
+          this.esbuildAvailable = true;
+        } catch {
+          this.esbuildAvailable = false;
+        }
+      }
+
+      if (this.esbuildAvailable) {
+        const esbuild = await import("esbuild") as EsbuildModule;
+        return { type: "esbuild", module: esbuild };
+      }
+    }
+
+    if (preferred === "swc") {
+      if (this.swcAvailable === null) {
+        try {
+          await import("@swc/core");
+          this.swcAvailable = true;
+        } catch {
+          this.swcAvailable = false;
+        }
+      }
+
+      if (this.swcAvailable) {
+        const swc = await import("@swc/core") as SwcModule;
+        return { type: "swc", module: swc };
+      }
+    }
+
+    // Fallback to esbuild if swc was preferred but not available
+    if (preferred === "swc" && this.esbuildAvailable !== false) {
+      return this.getTranspiler("esbuild");
+    }
+
+    return null;
+  }
+
+  /**
+   * Detect if source uses AssemblyScript-specific types
+   */
+  private detectAssemblyScript(source: string): boolean {
+    // AssemblyScript uses specific types: i8, i16, i32, i64, f32, f64, usize, etc.
+    const assemblyScriptTypes = /\b(i8|i16|i32|i64|f32|f64|usize|isize|bool)\b/;
+    return assemblyScriptTypes.test(source);
+  }
+
+  /**
+   * Basic syntax check for TypeScript
+   */
+  private checkBasicSyntax(source: string): string | null {
+    // Check for common syntax errors
+    const errors: string[] = [];
+
+    // Check for unmatched braces
+    const openBraces = (source.match(/\{/g) || []).length;
+    const closeBraces = (source.match(/\}/g) || []).length;
+    if (openBraces !== closeBraces) {
+      errors.push(`Unmatched braces: ${openBraces} open, ${closeBraces} close`);
+    }
+
+    // Check for unmatched parentheses
+    const openParens = (source.match(/\(/g) || []).length;
+    const closeParens = (source.match(/\)/g) || []).length;
+    if (openParens !== closeParens) {
+      errors.push(`Unmatched parentheses: ${openParens} open, ${closeParens} close`);
+    }
+
+    // Check for unmatched brackets
+    const openBrackets = (source.match(/\[/g) || []).length;
+    const closeBrackets = (source.match(/\]/g) || []).length;
+    if (openBrackets !== closeBrackets) {
+      errors.push(`Unmatched brackets: ${openBrackets} open, ${closeBrackets} close`);
+    }
+
+    return errors.length > 0 ? errors.join("; ") : null;
+  }
+}
+
+// Default instance
+export const typescriptCompiler = new TypeScriptCompiler();