smart-code-editor 1.0.0

package/src/config/themes.ts

@@ -0,0 +1,37 @@
+/**
+ * 主题配置
+ */
+
+export const THEME_CONFIGS = {
+  light: {
+    id: "vs",
+    name: "VS Light",
+    displayName: "浅色主题",
+  },
+  dark: {
+    id: "vs-dark",
+    name: "VS Dark",
+    displayName: "深色主题",
+  },
+  "high-contrast": {
+    id: "hc-black",
+    name: "High Contrast",
+    displayName: "高对比度",
+  },
+} as const;
+
+export type ThemeId = keyof typeof THEME_CONFIGS;
+
+/**
+ * 获取所有主题
+ */
+export function getAllThemes() {
+  return Object.values(THEME_CONFIGS);
+}
+
+/**
+ * 获取主题配置
+ */
+export function getThemeConfig(id: ThemeId) {
+  return THEME_CONFIGS[id];
+}

package/src/core/BackendRunner.ts

@@ -0,0 +1,329 @@
+/**
+ * 后端代码运行器
+ * 连接到 code-backend Rust 服务进行代码执行
+ */
+
+import type { RunResult, TestCase, TestCaseResult } from "../types";
+
+export interface BackendConfig {
+  /** API 基础 URL */
+  apiUrl?: string;
+  /** 请求超时时间（毫秒） */
+  timeout?: number;
+  /** 是否启用调试日志 */
+  debug?: boolean;
+}
+
+export interface BackendResponse {
+  stdout: string;
+  stderr: string;
+  exit_code: number;
+  execution_time_ms: number;
+  error: string;
+  test_results?: TestCaseResult[];
+}
+
+/**
+ * 后端运行器
+ * 通过 HTTP API 调用 code-backend 服务
+ */
+export class BackendRunner {
+  private config: Required<BackendConfig>;
+
+  constructor(config: BackendConfig = {}) {
+    this.config = {
+      apiUrl: config.apiUrl || "http://192.168.60.98:8080",
+      timeout: config.timeout || 30000,
+      debug: config.debug || false,
+    };
+  }
+
+  /**
+   * 运行代码
+   */
+  async run(
+    language: string,
+    code: string,
+    testCases?: TestCase[],
+    questionId?: number,
+  ): Promise<RunResult> {
+    const startTime = performance.now();
+
+    try {
+      if (this.config.debug) {
+        console.log("[BackendRunner] Running code:", {
+          language,
+          codeLength: code.length,
+          testCasesCount: testCases?.length || 0,
+          questionId,
+        });
+      }
+
+      const response = await this.fetchWithTimeout(
+        `${this.config.apiUrl}/api/v1/run`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            language,
+            code,
+            stdin: "",
+            testCases: testCases || null,
+            questionId: questionId || null,
+          }),
+        },
+        this.config.timeout,
+      );
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const result: BackendResponse = await response.json();
+
+      if (this.config.debug) {
+        console.log("[BackendRunner] Response:", result);
+      }
+
+      const executionTime =
+        result.execution_time_ms || performance.now() - startTime;
+
+      // 转换为前端格式
+      return this.convertResponse(result, executionTime);
+    } catch (error: any) {
+      if (this.config.debug) {
+        console.error("[BackendRunner] Error:", error);
+      }
+
+      return {
+        output: "",
+        error: this.formatError(error),
+        executionTime: performance.now() - startTime,
+        status: "error",
+      };
+    }
+  }
+
+  /**
+   * 提交代码（异步执行）
+   */
+  async submit(
+    language: string,
+    code: string,
+    testCases?: TestCase[],
+    questionId?: number,
+  ): Promise<string> {
+    try {
+      const response = await this.fetchWithTimeout(
+        `${this.config.apiUrl}/api/v1/submit`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            language,
+            code,
+            stdin: "",
+            testCases: testCases || null,
+            questionId: questionId || null,
+          }),
+        },
+        this.config.timeout,
+      );
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const result = await response.json();
+      return result.submissionId;
+    } catch (error: any) {
+      throw new Error(`提交失败: ${this.formatError(error)}`);
+    }
+  }
+
+  /**
+   * 查询提交状态
+   */
+  async getStatus(submissionId: string): Promise<{
+    status: "Pending" | "Running" | "Completed" | "Failed";
+    result?: BackendResponse;
+  }> {
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/api/v1/status/${submissionId}`,
+      );
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      return data;
+    } catch (error: any) {
+      throw new Error(`查询状态失败: ${this.formatError(error)}`);
+    }
+  }
+
+  /**
+   * 轮询等待结果
+   */
+  async waitForResult(
+    submissionId: string,
+    maxAttempts: number = 30,
+    interval: number = 1000,
+  ): Promise<RunResult> {
+    for (let i = 0; i < maxAttempts; i++) {
+      const status = await this.getStatus(submissionId);
+
+      if (status.status === "Completed" && status.result) {
+        return this.convertResponse(
+          status.result,
+          status.result.execution_time_ms,
+        );
+      }
+
+      if (status.status === "Failed") {
+        throw new Error("执行失败");
+      }
+
+      // 等待
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+
+    throw new Error("等待超时");
+  }
+
+  /**
+   * 获取题目信息
+   */
+  async getQuestion(questionId?: number): Promise<any> {
+    try {
+      const url = questionId
+        ? `${this.config.apiUrl}/api/v1/question?id=${questionId}`
+        : `${this.config.apiUrl}/api/v1/question`;
+
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      return await response.json();
+    } catch (error: any) {
+      throw new Error(`获取题目失败: ${this.formatError(error)}`);
+    }
+  }
+
+  /**
+   * 检查后端健康状态
+   */
+  async healthCheck(): Promise<boolean> {
+    try {
+      const response = await this.fetchWithTimeout(
+        `${this.config.apiUrl}/api/v1/question`,
+        { method: "GET" },
+        5000,
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 转换后端响应为前端格式
+   */
+  private convertResponse(
+    backendResult: BackendResponse,
+    executionTime: number,
+  ): RunResult {
+    const hasTestResults =
+      backendResult.test_results && backendResult.test_results.length > 0;
+
+    // 确定整体状态
+    let status: RunResult["status"] = "success";
+    if (backendResult.error) {
+      status = "error";
+    } else if (backendResult.exit_code !== 0) {
+      status = "error";
+    } else if (hasTestResults) {
+      const hasError = backendResult.test_results!.some(
+        (t) => t.status === "error",
+      );
+      const hasFailed = backendResult.test_results!.some(
+        (t) => t.status === "failed",
+      );
+      if (hasError || hasFailed) {
+        status = "error";
+      }
+    }
+
+    return {
+      output: backendResult.stdout,
+      error: backendResult.stderr || backendResult.error || undefined,
+      executionTime,
+      status,
+      testResults: backendResult.test_results,
+    };
+  }
+
+  /**
+   * 格式化错误信息
+   */
+  private formatError(error: any): string {
+    if (error.name === "AbortError") {
+      return `请求超时（${this.config.timeout}ms）`;
+    }
+
+    if (error.message) {
+      return error.message;
+    }
+
+    return String(error);
+  }
+
+  /**
+   * 带超时的 fetch
+   */
+  private fetchWithTimeout(
+    url: string,
+    options: RequestInit,
+    timeout: number,
+  ): Promise<Response> {
+    return Promise.race([
+      fetch(url, options),
+      new Promise<Response>((_, reject) => {
+        setTimeout(() => {
+          const error = new Error("Request timeout");
+          error.name = "AbortError";
+          reject(error);
+        }, timeout);
+      }),
+    ]);
+  }
+
+  /**
+   * 更新配置
+   */
+  setConfig(config: Partial<BackendConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  /**
+   * 获取当前配置
+   */
+  getConfig(): Readonly<Required<BackendConfig>> {
+    return { ...this.config };
+  }
+}
+
+/**
+ * 创建默认的后端运行器实例
+ */
+export function createBackendRunner(config?: BackendConfig): BackendRunner {
+  return new BackendRunner(config);
+}

package/src/core/CodeRunner.ts

@@ -0,0 +1,107 @@
+import type { RunResult } from "../types";
+import { getRunnerStrategy } from "../config/runnerStrategies";
+
+/**
+ * 代码运行引擎
+ * 使用策略模式支持多种语言
+ */
+export class CodeRunner {
+  private timeout: number;
+  private abortController: AbortController | null = null;
+
+  constructor(timeout: number = 5000) {
+    this.timeout = timeout;
+  }
+
+  /**
+   * 运行代码
+   */
+  async run(
+    code: string,
+    language: string,
+    testCases?: import("../types").TestCase[],
+  ): Promise<RunResult> {
+    // 获取对应语言的运行策略
+    const strategy = getRunnerStrategy(language);
+
+    if (!strategy) {
+      return {
+        output: "",
+        error: `语言 "${language}" 不支持运行`,
+        executionTime: 0,
+        status: "error",
+      };
+    }
+
+    // 创建超时控制
+    this.abortController = new AbortController();
+    const timeoutId = setTimeout(() => {
+      this.abortController?.abort();
+    }, this.timeout);
+
+    try {
+      // 执行代码
+      const result = await Promise.race([
+        strategy(code, testCases),
+        this.createTimeoutPromise(),
+      ]);
+
+      clearTimeout(timeoutId);
+      return result;
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+
+      if (error.name === "AbortError") {
+        return {
+          output: "",
+          error: `执行超时（${this.timeout}ms）`,
+          executionTime: this.timeout,
+          status: "timeout",
+        };
+      }
+
+      return {
+        output: "",
+        error: error.message || String(error),
+        executionTime: 0,
+        status: "error",
+      };
+    } finally {
+      this.abortController = null;
+    }
+  }
+
+  /**
+   * 创建超时 Promise
+   */
+  private createTimeoutPromise(): Promise<RunResult> {
+    return new Promise((_, reject) => {
+      this.abortController?.signal.addEventListener("abort", () => {
+        const error = new Error("Execution timeout");
+        error.name = "AbortError";
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * 取消运行
+   */
+  cancel(): void {
+    this.abortController?.abort();
+  }
+
+  /**
+   * 设置超时时间
+   */
+  setTimeout(timeout: number): void {
+    this.timeout = timeout;
+  }
+
+  /**
+   * 销毁
+   */
+  destroy(): void {
+    this.cancel();
+  }
+}

package/src/core/LanguageManager.ts

@@ -0,0 +1,108 @@
+import type { LanguageConfig } from "../types";
+import { LANGUAGE_CONFIGS, getLanguageConfig } from "../config/languages";
+
+/**
+ * 语言管理器
+ * 负责管理支持的编程语言，从配置文件读取
+ */
+export class LanguageManager {
+  private languages: Map<string, LanguageConfig> = new Map();
+  private currentLanguage: LanguageConfig;
+
+  constructor(defaultLanguage: string = "javascript") {
+    // 从配置加载所有语言
+    LANGUAGE_CONFIGS.forEach((config) => {
+      this.languages.set(config.id, config);
+    });
+
+    // 设置默认语言
+    const lang = this.languages.get(defaultLanguage);
+    if (!lang) {
+      throw new Error(`Language "${defaultLanguage}" not found in config`);
+    }
+    this.currentLanguage = lang;
+  }
+
+  /**
+   * 获取指定语言配置
+   */
+  getLanguage(id: string): LanguageConfig | undefined {
+    return this.languages.get(id);
+  }
+
+  /**
+   * 获取所有语言
+   */
+  getAllLanguages(): LanguageConfig[] {
+    return Array.from(this.languages.values());
+  }
+
+  /**
+   * 切换语言
+   */
+  switchLanguage(languageId: string): LanguageConfig {
+    const lang = this.languages.get(languageId);
+    if (!lang) {
+      throw new Error(`Language "${languageId}" not supported`);
+    }
+    this.currentLanguage = lang;
+    return this.currentLanguage;
+  }
+
+  /**
+   * 获取当前语言
+   */
+  getCurrentLanguage(): LanguageConfig {
+    return this.currentLanguage;
+  }
+
+  /**
+   * 检查语言是否支持
+   */
+  isSupported(languageId: string): boolean {
+    return this.languages.has(languageId);
+  }
+
+  /**
+   * 获取可运行的语言列表
+   */
+  getRunnableLanguages(): LanguageConfig[] {
+    return Array.from(this.languages.values()).filter((lang) => lang.canRun);
+  }
+
+  /**
+   * 获取语言的代码模板（支持外部配置）
+   * 优先级: languageTemplates > questionConfig > fallbackTemplate > 空字符串
+   */
+  getTemplate(
+    languageId: string,
+    questionConfig?: import("../types/question").QuestionConfig,
+    languageTemplates?: import("../types/question").LanguageTemplates,
+  ): string {
+    // 优先级 1: 直接传入的 languageTemplates
+    if (
+      languageTemplates &&
+      languageTemplates[languageId] !== undefined &&
+      languageTemplates[languageId] !== null
+    ) {
+      return languageTemplates[languageId];
+    }
+
+    // 优先级 2: questionConfig 中的模板
+    if (
+      questionConfig?.languageTemplates?.[languageId] !== undefined &&
+      questionConfig?.languageTemplates?.[languageId] !== null
+    ) {
+      return questionConfig.languageTemplates[languageId];
+    }
+
+    // 优先级 3: 语言的 fallbackTemplate
+    const langConfig = this.languages.get(languageId);
+    if (langConfig && (langConfig as any).fallbackTemplate) {
+      return (langConfig as any).fallbackTemplate;
+    }
+
+    // 优先级 4: 空字符串（允许用户从空白开始）
+    return "";
+  }
+}