fix: 修复monaco override dispose 问题

Author: guqiankun.gqk

packages/core/src/client/index.ts

@@ -10,7 +10,7 @@ import {
 } from '@opensumi/ide-core-browser';
 import { ClientApp as BasicClientApp } from '@opensumi/ide-core-browser/lib/bootstrap/app';
 
-import { BackService, BasicModule } from '@opensumi/ide-core-common';
+import { BackService, BasicModule, Disposable } from '@opensumi/ide-core-common';
 import { WSChannelHandler } from '@opensumi/ide-connection/lib/browser';
 
 import { FCServiceCenter, ClientPort, initFCService } from '../connection';
@@ -36,8 +36,8 @@ import { LayoutRestoreContributation } from './layout/index.contribution';
 import {
   MonacoCodeService,
   IMonacoCodeService,
-  codeServiceEditor,
-} from './override/codeEditorService';
+  monacoCodeServiceProxy,
+} from './override/monacoOverride/codeEditorService';
 import { BreadCrumbServiceImplOverride, IBreadCrumbService } from './override/breadcrumb.service';
 import { SearchContribution } from './search/index.contribution';
 import {
@@ -51,7 +51,24 @@ import {
 } from './override/vscodeContributesService';
 
 import { ExtensionNodeServiceServerPath } from '@opensumi/ide-extension';
-export * from './override/codeEditorService';
+import {
+  IMonacoTextModelService,
+  MonacoTextModelService,
+  monacoTextModelServiceProxy,
+} from './override/monacoOverride/textModelService';
+import {
+  IMonacoBulkEditServiceProxy,
+  MonacoBulkEditService,
+  monacoBulkEditServiceProxy,
+} from './override/monacoOverride/workspaceEditService';
+import { ICommandServiceToken } from '@opensumi/ide-monaco/lib/browser/contrib/command';
+import { MonacoCommandService } from '@opensumi/ide-editor/lib/browser/monaco-contrib/command/command.service';
+import { IBulkEditServiceShape } from '@opensumi/ide-workspace-edit';
+import {
+  IMonacoCommandServiceProxy,
+  monacoCommandServiceProxy,
+} from './override/monacoOverride/commandService';
+export * from './override/monacoOverride/codeEditorService';
 
 export { ExtensionManagerModule as ExtensionClientManagerModule } from './extension-manager';
 
@@ -80,27 +97,66 @@ export class ClientModule extends BrowserModule {
     SearchContribution,
     PreferenceSettingContribution,
     LayoutRestoreContributation,
+
+    /*  monaco override*/
     {
       token: MonacoCodeService,
-      useValue: codeServiceEditor,
+      useValue: monacoCodeServiceProxy,
+      override: true,
     },
     {
       token: IMonacoCodeService,
       useClass: MonacoCodeService,
     },
+    // MonacoTextModelService
     {
-      token: IBreadCrumbService,
-      useClass: BreadCrumbServiceImplOverride,
+      token: MonacoTextModelService,
+      useValue: monacoTextModelServiceProxy,
       override: true,
     },
     {
-      token: MonacoSnippetSuggestProvider,
-      useClass: MonacoSnippetSuggestProviderOverride,
+      token: IMonacoTextModelService,
+      useClass: MonacoTextModelService,
+    },
+    // IBulkEditServiceShape
+    {
+      token: IBulkEditServiceShape,
+      useValue: monacoBulkEditServiceProxy,
+      override: true,
+    },
+    {
+      token: IMonacoBulkEditServiceProxy,
+      useClass: MonacoBulkEditService,
+    },
+    // MonacoCommandService
+    {
+      token: ICommandServiceToken,
+      useValue: monacoCommandServiceProxy,
       override: true,
     },
+    {
+      token: IMonacoCommandServiceProxy,
+      useClass: MonacoCommandService,
+    },
+    // MonacoContextKeyService
     {
       token: IContextKeyService,
-      useClass: MonacoContextKeyService,
+      useValue: monacoCommandServiceProxy,
+      override: true,
+    },
+    {
+      token: IMonacoCommandServiceProxy,
+      useClass: MonacoCommandService,
+    },
+    /* monaco override */
+    {
+      token: IBreadCrumbService,
+      useClass: BreadCrumbServiceImplOverride,
+      override: true,
+    },
+    {
+      token: MonacoSnippetSuggestProvider,
+      useClass: MonacoSnippetSuggestProviderOverride,
       override: true,
     },
     {
@@ -126,15 +182,21 @@ export class ClientApp extends BasicClientApp {
 
   private modules: ModuleConstructor[] = [];
 
+  private disposer = new Disposable();
+
   constructor(opts: IAppOpts) {
     super(opts);
     this.modules = opts.modules;
     this.initServer(opts);
-    this.initCodeServiceEditor();
+    // monaco override proxy 防止组件卸载后 monaco override 实例被销毁
+    this.initMonacoProxy();
   }
 
-  initCodeServiceEditor() {
-    this.clearInjector = codeServiceEditor.setInjector(this.injector);
+  initMonacoProxy() {
+    this.disposer.addDispose(monacoCodeServiceProxy.setInjector(this.injector));
+    this.disposer.addDispose(monacoTextModelServiceProxy.setInjector(this.injector));
+    this.disposer.addDispose(monacoBulkEditServiceProxy.setInjector(this.injector));
+    this.disposer.addDispose(monacoCommandServiceProxy.setInjector(this.injector));
   }
 
   private initServer(opts: IAppOpts) {
@@ -190,7 +252,7 @@ export class ClientApp extends BasicClientApp {
   }
   async dispose() {
     super.dispose();
-    this.clearInjector();
+    this.disposer.dispose();
   }
 }
 

packages/core/src/client/override/monacoContextKeyService.ts

@@ -15,6 +15,7 @@ export class MonacoContextKeyService extends BaseContextKeyService implements IC
       (window as any)?._alex?.ContextKeyService || new ContextKeyService(this.configurationService);
     (window as any)._alex = {};
     (window as any)._alex.ContextKeyService = this.contextKeyService;
+    this.listenToContextChanges();
   }
 
   dispose(): void {}

…src/client/override/codeEditorService.ts …ride/monacoOverride/codeEditorService.tspackages/core/src/client/override/codeEditorService.ts renamed to packages/core/src/client/override/monacoOverride/codeEditorService.ts packages/core/src/client/override/codeEditorService.ts renamed to packages/core/src/client/override/monacoOverride/codeEditorService.ts

@@ -15,7 +15,7 @@ export const IMonacoCodeService = Symbol('IMonacoCodeService');
 
 export { MonacoCodeService };
 
-class CodeEditorService extends AbstractCodeEditorService {
+class MonacoCodeServiceProxy extends AbstractCodeEditorService {
   private injector: Injector | null = null;
   private uid = 0;
 
@@ -27,10 +27,12 @@ class CodeEditorService extends AbstractCodeEditorService {
     this.injector = injector;
     this.uid++;
     const currentUId = this.uid;
-    return () => {
-      if (currentUId === this.uid) {
-        this.injector = null;
-      }
+    return {
+      dispose: () => {
+        if (currentUId === this.uid && this.injector) {
+          this.injector = null;
+        }
+      },
     };
   }
 
@@ -43,4 +45,4 @@ class CodeEditorService extends AbstractCodeEditorService {
   }
 }
 
-export const codeServiceEditor = new CodeEditorService();
+export const monacoCodeServiceProxy = new MonacoCodeServiceProxy();

packages/core/src/client/override/monacoOverride/commandService.ts

@@ -0,0 +1,50 @@
+import { MonacoTextModelService } from '@opensumi/ide-editor/lib/browser/doc-model/override';
+import { Injector } from '@opensumi/di';
+
+import {
+  ICommandServiceToken,
+  IMonacoActionRegistry,
+  IMonacoCommandsRegistry,
+  IMonacoCommandService,
+  ICommandEvent,
+  ICommandService,
+} from '@opensumi/ide-monaco/lib/browser/contrib/command';
+import { Event } from '@opensumi/ide-monaco';
+
+export const IMonacoCommandServiceProxy = Symbol('IMonacoCommandServiceProxy');
+export { MonacoTextModelService };
+
+class MonacoCommandServiceProxy implements IMonacoCommandService {
+  _serviceBrand: undefined;
+
+  private injector: Injector | null = null;
+  private uid = 0;
+
+  setInjector(injector: Injector) {
+    this.injector = injector;
+    this.uid++;
+    const currentUId = this.uid;
+    return {
+      dispose: () => {
+        if (currentUId === this.uid && this.injector) {
+          this.injector = null;
+        }
+      },
+    };
+  }
+
+  setDelegate(delegate: ICommandService): void {
+    return this.injector!.get(IMonacoCommandServiceProxy).setDelegate(delegate);
+  }
+  get onWillExecuteCommand(): Event<ICommandEvent> {
+    return this.injector!.get(IMonacoCommandServiceProxy).onWillExecuteCommand;
+  }
+  get onDidExecuteCommand(): Event<ICommandEvent> {
+    return this.injector!.get(IMonacoCommandServiceProxy).onDidExecuteCommand;
+  }
+  executeCommand<T = any>(commandId: string, ...args: any[]): Promise<T | undefined> {
+    return this.injector!.get(IMonacoCommandServiceProxy).executeCommand(commandId, ...args);
+  }
+}
+
+export const monacoCommandServiceProxy = new MonacoCommandServiceProxy();

packages/core/src/client/override/monacoOverride/contextKeyService.ts

@@ -0,0 +1,78 @@
+import { Injector } from '@opensumi/di';
+import {
+  ContextKeyChangeEvent,
+  Event,
+  IContextKey,
+  IScopedContextKeyService,
+} from '@opensumi/ide-core-browser';
+import { ContextKeyService } from '@opensumi/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
+import {
+  ContextKeyValue,
+  ContextKeyExpr,
+  IContextKeyService,
+  IContextKeyServiceTarget,
+} from '@opensumi/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+export const IScopedContextKeyServiceProxy = Symbol('IScopedContextKeyServiceProxy');
+
+// override 传入的是scope
+
+class ScopedContextKeyServiceProxy implements IScopedContextKeyService {
+  private injector: Injector | null = null;
+  private uid = 0;
+
+  setInjector(injector: Injector) {
+    this.injector = injector;
+    this.uid++;
+    const currentUId = this.uid;
+    return {
+      dispose: () => {
+        if (currentUId === this.uid && this.injector) {
+          this.injector = null;
+        }
+      },
+    };
+  }
+
+  attachToDomNode(domNode: HTMLElement): void {
+    return this.injector!.get(IScopedContextKeyServiceProxy).attachToDomNode(domNode);
+  }
+  onDidChangeContext: Event<ContextKeyChangeEvent>;
+  bufferChangeEvents(callback: Function): void {
+    return this.injector!.get(IScopedContextKeyServiceProxy).bufferChangeEvents(callback);
+  }
+  getValue<T>(key: string): T | undefined {
+    return this.injector!.get(IScopedContextKeyServiceProxy).getValue(key);
+  }
+  createKey<T extends ContextKeyValue = any>(
+    key: string,
+    defaultValue: T | undefined
+  ): IContextKey<T> {
+    return this.injector!.get(IScopedContextKeyServiceProxy).createKey(key, defaultValue);
+  }
+  match(
+    expression: string | ContextKeyExpr | undefined,
+    context?: HTMLElement | null | undefined
+  ): boolean {
+    return this.injector!.get(IScopedContextKeyServiceProxy).match(expression, context);
+  }
+  getKeysInWhen(when: string | ContextKeyExpr | undefined): string[] {
+    return this.injector!.get(IScopedContextKeyServiceProxy).getKeysInWhen(when);
+  }
+  getContextValue<T>(key: string): T | undefined {
+    return this.injector!.get(IScopedContextKeyServiceProxy).getContextValue(key);
+  }
+  contextKeyService: IContextKeyService;
+  createScoped(
+    target?: ContextKeyService | IContextKeyServiceTarget | undefined
+  ): IScopedContextKeyService {
+    return this.injector!.get(IScopedContextKeyServiceProxy).createScoped(target);
+  }
+  parse(when: string | undefined): ContextKeyExpr | undefined {
+    throw new Error('Method not implemented.');
+  }
+  dispose(): void {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export const monacoTextModelServiceProxy = new ScopedContextKeyServiceProxy();

packages/core/src/client/override/monacoOverride/textModelService.ts

@@ -0,0 +1,53 @@
+import {
+  ITextModelService,
+  ITextModelContentProvider,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/common/services/resolverService';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+import { MonacoTextModelService } from '@opensumi/ide-editor/lib/browser/doc-model/override';
+import { Injector } from '@opensumi/di';
+export const IMonacoTextModelService = Symbol('IMonacoTextModelService');
+export { MonacoTextModelService };
+
+class MonacoTextModelServiceProxy implements ITextModelService {
+  _serviceBrand: undefined;
+
+  private injector: Injector | null = null;
+  private uid = 0;
+
+  setInjector(injector: Injector) {
+    this.injector = injector;
+    this.uid++;
+    const currentUId = this.uid;
+    return {
+      dispose: () => {
+        if (currentUId === this.uid && this.injector) {
+          this.injector = null;
+        }
+      },
+    };
+  }
+
+  canHandleResource(resource: any): boolean {
+    return this.injector!.get(IMonacoTextModelService).canHandleResource(resource);
+  }
+
+  hasTextModelContentProvider(scheme: string): boolean {
+    return this.injector!.get(IMonacoTextModelService).hasTextModelContentProvider(scheme);
+  }
+
+  async createModelReference(resource: monaco.Uri) {
+    return this.injector!.get(IMonacoTextModelService).createModelReference(resource);
+  }
+
+  registerTextModelContentProvider(
+    scheme: string,
+    provider: ITextModelContentProvider
+  ): monaco.IDisposable {
+    return this.injector!.get(IMonacoTextModelService).registerTextModelContentProvider(
+      scheme,
+      provider
+    );
+  }
+}
+
+export const monacoTextModelServiceProxy = new MonacoTextModelServiceProxy();