refactor(core): 重构视图触发器的懒加载机制

- 新增 `LazyViewHost` 类，统一管理视图触发器的懒加载代理
- 重构 `FeatureLoader`，将视图触发器的注册逻辑委托给 `LazyViewHost`
- 更新相关单元测试，验证代理机制能正确传递数据与刷新事件
- 新增智能翻译 API 切换的设计文档与实现计划

Author: Sisyphean-a

docs/plans/2026-03-06-smart-translate-api-design.md

@@ -0,0 +1,17 @@
+# Smart Translate API Switch Design
+
+**Goal:** 将智能翻译底层接口从当前谷歌接口切换到 `https://fanyi.sisyphean.top/single`，同时保持现有交互与“中文转英文，非中文转中文”的业务规则不变。
+
+**Scope:** 仅调整 `src/features/smartTranslate/translator.ts` 的请求与响应解析，并补充对应单元测试。
+
+**Design:**
+- 保留本地 `LanguageDetector` 的方向判断：`zh -> en`，其他 -> `zh`。
+- 调用新接口时，将内部目标语言 `zh` 映射为接口所需的 `zh_CN`；英文保持 `en`。
+- 响应解析从旧的 `sentences[].trans` 改为读取 `translation`。
+- 如果返回 `info.detectedSource`，则优先作为结果中的 `sourceLanguage`，否则回退到本地检测值。
+- 保留现有缓存、复合词预处理与错误抛出行为。
+
+**Testing:**
+- 新增 `src/test/smartTranslate/translator.test.ts`。
+- 覆盖中文转英文与英文转中文两个方向的参数映射和响应解析。
+- 通过子类覆写 HTTP 请求方法避免真实网络请求。

docs/plans/2026-03-06-smart-translate-api-plan.md

@@ -0,0 +1,59 @@
+# Smart Translate API Switch Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** 把智能翻译改为调用新的 `/single` GET 接口，并保持原有中文/非中文的翻译方向规则。
+
+**Architecture:** 仅修改翻译服务层，维持上层选择监听、状态栏展示、命名建议逻辑不变。通过新增翻译服务单测，先验证新接口的 URL 参数和响应解析，再做最小实现。
+
+**Tech Stack:** TypeScript, Mocha, VS Code extension test setup
+
+---
+
+### Task 1: 为翻译服务补充失败测试
+
+**Files:**
+- Create: `src/test/smartTranslate/translator.test.ts`
+- Test: `src/test/smartTranslate/translator.test.ts`
+
+**Step 1: Write the failing test**
+- 验证中文输入会请求 `tl=en`
+- 验证英文输入会请求 `tl=zh_CN`
+- 验证响应从 `translation` 字段解析译文
+- 验证 `info.detectedSource` 会回填到结果中
+
+**Step 2: Run test to verify it fails**
+- Run: `npx tsc -p . --outDir out`
+- Expected: 测试编译通过，但新测试因当前实现 URL/解析不匹配而失败（随后运行测试或静态断言可见）
+
+### Task 2: 最小化修改翻译服务
+
+**Files:**
+- Modify: `src/features/smartTranslate/translator.ts`
+- Test: `src/test/smartTranslate/translator.test.ts`
+
+**Step 1: Write minimal implementation**
+- 提取新接口地址常量
+- 映射目标语言到接口值
+- 按新 JSON 结构解析 `translation`
+- 保持错误显式抛出，不加兜底
+
+**Step 2: Run test to verify it passes**
+- Run: `npm run compile-tests`
+- Expected: 编译通过
+- Run: `npm run lint -- src/features/smartTranslate/translator.ts src/test/smartTranslate/translator.test.ts`
+- Expected: 相关文件无 lint 错误
+
+### Task 3: 做一次收尾验证
+
+**Files:**
+- Modify: `src/features/smartTranslate/translator.ts`
+- Test: `src/test/smartTranslate/translator.test.ts`
+
+**Step 1: Verify focused checks**
+- Run: `npm run compile-tests`
+- Run: `npm run lint`
+
+**Step 2: Confirm behavior surface**
+- 确认未改动 `src/features/smartTranslate/index.ts` 的调用方式
+- 确认命名建议仍依赖 `sourceLanguage === "zh"`

src/featureLoader.ts

@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import { FeatureActivationResult, FeatureModule } from "./types/feature";
 import { Logger } from "./logger";
+import { LazyViewHost } from "./lazyViewHost";
 
 const PERF_PREFIX = "[perf]";
 
@@ -17,7 +18,8 @@ export class FeatureLoader {
   private activatedModules = new Set<string>();
   private activationResults = new Map<string, FeatureActivationResult>();
   private initializingModules = new Map<string, Promise<FeatureActivationResult>>();
-  private lazyEntrypoints = new Map<string, vscode.Disposable[]>();
+  private lazyCommandEntrypoints = new Map<string, vscode.Disposable[]>();
+  private lazyViewHost = new LazyViewHost();
 
   register(module: FeatureModule): void {
     if (this.modules.has(module.name)) {
@@ -151,7 +153,7 @@ export class FeatureLoader {
         disposable?.dispose();
         await vscode.commands.executeCommand(commandId, ...args);
       });
-      this.trackLazyEntrypoint(module.name, disposable);
+      this.trackLazyCommandEntrypoint(module.name, disposable);
       context.subscriptions.push(disposable);
     }
   }
@@ -162,20 +164,12 @@ export class FeatureLoader {
   ): void {
     const triggers = module.viewTriggers ?? [];
     for (const viewId of triggers) {
-      let disposable: vscode.Disposable | undefined;
-      disposable = vscode.window.registerTreeDataProvider(viewId, {
-        getTreeItem: (element: vscode.TreeItem) => element,
-        getChildren: async () => {
-          const result = await this.ensureModuleActivated(module.name, context);
-          if (!result.success) {
-            return [new vscode.TreeItem(`模块 ${module.name} 加载失败`)];
-          }
-          disposable?.dispose();
-          return [];
-        },
-      });
-      this.trackLazyEntrypoint(module.name, disposable);
-      context.subscriptions.push(disposable);
+      this.lazyViewHost.registerPlaceholder(
+        viewId,
+        module.name,
+        () => this.ensureModuleActivated(module.name, context),
+        context
+      );
     }
   }
 
@@ -215,8 +209,11 @@ export class FeatureLoader {
     try {
       const started = Date.now();
       Logger.debug(`正在激活模块: ${module.name}...`);
-      this.disposeLazyEntrypoints(module.name);
-      const result = await module.activate(context);
+      this.disposeLazyCommandEntrypoints(module.name);
+      const result = await this.lazyViewHost.withInterception(
+        module.viewTriggers,
+        () => module.activate(context)
+      );
       const elapsed = Date.now() - started;
       Logger.info(`${PERF_PREFIX}[module:${module.name}] 激活耗时 ${elapsed}ms`);
 
@@ -258,22 +255,22 @@ export class FeatureLoader {
       });
   }
 
-  private trackLazyEntrypoint(moduleName: string, disposable: vscode.Disposable): void {
-    const entrypoints = this.lazyEntrypoints.get(moduleName) ?? [];
+  private trackLazyCommandEntrypoint(moduleName: string, disposable: vscode.Disposable): void {
+    const entrypoints = this.lazyCommandEntrypoints.get(moduleName) ?? [];
     entrypoints.push(disposable);
-    this.lazyEntrypoints.set(moduleName, entrypoints);
+    this.lazyCommandEntrypoints.set(moduleName, entrypoints);
   }
 
-  private disposeLazyEntrypoints(moduleName: string): void {
-    const entrypoints = this.lazyEntrypoints.get(moduleName);
+  private disposeLazyCommandEntrypoints(moduleName: string): void {
+    const entrypoints = this.lazyCommandEntrypoints.get(moduleName);
     if (!entrypoints) {
       return;
     }
 
     for (const entrypoint of entrypoints) {
       entrypoint.dispose();
     }
-    this.lazyEntrypoints.delete(moduleName);
+    this.lazyCommandEntrypoints.delete(moduleName);
   }
 }
 

src/lazyViewHost.ts

@@ -0,0 +1,131 @@
+import * as vscode from "vscode";
+import { FeatureActivationResult } from "./types/feature";
+
+type ViewProvider = vscode.TreeDataProvider<any>;
+type ViewEntry = {
+  proxy: LazyTreeDataProviderProxy;
+  treeView: vscode.TreeView<any>;
+};
+
+class LazyTreeDataProviderProxy implements vscode.TreeDataProvider<any>, vscode.Disposable {
+  private delegate?: ViewProvider;
+  private delegateSubscription?: vscode.Disposable;
+  private readonly emitter = new vscode.EventEmitter<any>();
+  readonly onDidChangeTreeData = this.emitter.event;
+
+  constructor(
+    private readonly moduleName: string,
+    private readonly viewId: string,
+    private readonly activate: () => Promise<FeatureActivationResult>
+  ) {}
+
+  attach(provider: ViewProvider): void {
+    this.delegate = provider;
+    this.delegateSubscription?.dispose();
+    this.delegateSubscription = provider.onDidChangeTreeData?.(() => this.emitter.fire(undefined));
+    this.emitter.fire(undefined);
+  }
+
+  detach(provider?: ViewProvider): void {
+    if (provider && this.delegate !== provider) {
+      return;
+    }
+
+    this.delegateSubscription?.dispose();
+    this.delegateSubscription = undefined;
+    this.delegate = undefined;
+    this.emitter.fire(undefined);
+  }
+
+  getTreeItem(element: any): vscode.TreeItem | Thenable<vscode.TreeItem> {
+    if (this.delegate) {
+      return this.delegate.getTreeItem(element);
+    }
+    return element instanceof vscode.TreeItem ? element : new vscode.TreeItem(String(element));
+  }
+
+  async getChildren(element?: any): Promise<any[]> {
+    if (!this.delegate) {
+      const result = await this.activate();
+      if (!result.success) {
+        return [new vscode.TreeItem(`模块 ${this.moduleName} 加载失败`)];
+      }
+      if (result.disabled) {
+        return [new vscode.TreeItem(`功能 \"${this.moduleName}\" 已被禁用`)];
+      }
+      if (!this.delegate) {
+        return [new vscode.TreeItem(`视图 ${this.viewId} 未注册数据提供器`)];
+      }
+    }
+
+    return (await this.delegate.getChildren(element)) ?? [];
+  }
+
+  dispose(): void {
+    this.detach();
+    this.emitter.dispose();
+  }
+}
+
+export class LazyViewHost {
+  private entries = new Map<string, ViewEntry>();
+
+  registerPlaceholder(
+    viewId: string,
+    moduleName: string,
+    activate: () => Promise<FeatureActivationResult>,
+    context: vscode.ExtensionContext
+  ): void {
+    const proxy = new LazyTreeDataProviderProxy(moduleName, viewId, activate);
+    const treeView = vscode.window.createTreeView(viewId, {
+      treeDataProvider: proxy,
+      showCollapseAll: true,
+    });
+
+    this.entries.set(viewId, { proxy, treeView });
+    context.subscriptions.push(proxy, treeView);
+  }
+
+  async withInterception<T>(viewIds: readonly string[] | undefined, task: () => Promise<T> | T): Promise<T> {
+    if (!viewIds?.length) {
+      return await Promise.resolve(task());
+    }
+
+    const originalRegister = vscode.window.registerTreeDataProvider;
+    const originalCreate = vscode.window.createTreeView;
+
+    vscode.window.registerTreeDataProvider = ((viewId: string, provider: ViewProvider) => {
+      const entry = this.match(viewIds, viewId);
+      if (!entry) {
+        return originalRegister(viewId, provider);
+      }
+
+      entry.proxy.attach(provider);
+      return new vscode.Disposable(() => entry.proxy.detach(provider));
+    }) as typeof vscode.window.registerTreeDataProvider;
+
+    vscode.window.createTreeView = ((viewId: string, options: vscode.TreeViewOptions<any>) => {
+      const entry = this.match(viewIds, viewId);
+      if (!entry) {
+        return (originalCreate as any)(viewId, options);
+      }
+
+      entry.proxy.attach(options.treeDataProvider);
+      return entry.treeView;
+    }) as typeof vscode.window.createTreeView;
+
+    try {
+      return await Promise.resolve(task());
+    } finally {
+      vscode.window.registerTreeDataProvider = originalRegister;
+      vscode.window.createTreeView = originalCreate;
+    }
+  }
+
+  private match(viewIds: readonly string[], viewId: string): ViewEntry | undefined {
+    if (!viewIds.includes(viewId)) {
+      return undefined;
+    }
+    return this.entries.get(viewId);
+  }
+}