@opensumi/ide-editor 2.21.13 → 2.22.0

package/src/browser/history/index.ts

@@ -0,0 +1,228 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  IPosition,
+  URI,
+  WithEventBus,
+  OnEvent,
+  PreferenceService,
+  addDisposableListener,
+  EventType,
+  DisposableCollection,
+} from '@opensumi/ide-core-browser';
+
+import { WorkbenchEditorService } from '../../common';
+import { EditorSelectionChangeEvent, EditorGroupChangeEvent, EditorGroupCloseEvent, EditorOpenType } from '../types';
+
+const HistoryPositionLineThreshold = 7;
+const HardMaxStateLength = 200; // 超过200个过后，会缩减至100个, 防止反复缩减
+const SoftMaxStateLength = 100;
+
+@Injectable()
+export class EditorHistoryService extends WithEventBus {
+  private static readonly MOUSE_NAVIGATION_SETTING = 'editor.mouseBackForwardToNavigate';
+
+  @Autowired(PreferenceService)
+  private preferenceService: PreferenceService;
+
+  @Autowired(WorkbenchEditorService)
+  private editorService: WorkbenchEditorService;
+
+  private currentIndex = -1;
+
+  private stack: EditorHistoryState[] = [];
+
+  private closedStack: URI[] = [];
+
+  init() {
+    this.registerMouseNavigationListener();
+  }
+
+  private registerMouseNavigationListener() {
+    const disposables = new DisposableCollection();
+    const handleMouseBackForwardSupport = () => {
+      disposables.dispose();
+      if (this.preferenceService.get(EditorHistoryService.MOUSE_NAVIGATION_SETTING)) {
+        disposables.push(addDisposableListener(window.document, EventType.MOUSE_DOWN, (e) => this.onMouseDown(e)));
+      }
+      this.disposables.push(disposables);
+    };
+    this.disposables.push(
+      this.preferenceService.onSpecificPreferenceChange(EditorHistoryService.MOUSE_NAVIGATION_SETTING, () => {
+        if (this.preferenceService.get(EditorHistoryService.MOUSE_NAVIGATION_SETTING)) {
+          handleMouseBackForwardSupport();
+        }
+      }),
+    );
+    handleMouseBackForwardSupport();
+  }
+
+  private onMouseDown(event: MouseEvent) {
+    // Support to navigate in history when mouse buttons 4/5 are pressed
+    switch (event.button) {
+      case 3:
+        event.stopPropagation();
+        this.back();
+        break;
+      case 4:
+        event.stopPropagation();
+        this.forward();
+        break;
+    }
+  }
+
+  @OnEvent(EditorSelectionChangeEvent)
+  onEditorSelectionChangeEvent(e: EditorSelectionChangeEvent) {
+    if (e.payload.selections[0]) {
+      this.onNewState(
+        new EditorHistoryState(
+          e.payload.editorUri,
+          {
+            lineNumber: e.payload.selections[0]!.selectionStartLineNumber,
+            column: e.payload.selections[0]!.selectionStartColumn,
+          },
+          e.payload.group.index,
+          false,
+        ),
+      );
+    }
+  }
+
+  @OnEvent(EditorGroupChangeEvent)
+  onEditorGroupChangeEvent(e: EditorGroupChangeEvent) {
+    if (
+      e.payload.newOpenType &&
+      (e.payload.newOpenType.type === EditorOpenType.code || e.payload.newOpenType.type === EditorOpenType.diff)
+    ) {
+      const selections = e.payload.group.currentEditor!.getSelections();
+      if (selections && selections.length > 0) {
+        this.onNewState(
+          new EditorHistoryState(
+            e.payload.newResource!.uri,
+            {
+              lineNumber: selections[0].selectionStartLineNumber,
+              column: selections[0]!.selectionStartColumn,
+            },
+            e.payload.group.index,
+            true,
+          ),
+        );
+      }
+    }
+  }
+
+  @OnEvent(EditorGroupCloseEvent)
+  onEditorGroupCloseEvent(e: EditorGroupCloseEvent) {
+    this.pushClosed(e.payload.resource.uri);
+  }
+
+  onNewState(state: EditorHistoryState) {
+    if (this.currentIndex !== this.stack.length - 1) {
+      if (state.isTabChange && this.currentState.isRelevant(state)) {
+        //
+        return;
+      }
+      if (this.currentState && this.currentState.isEqual(state)) {
+        // 这个状态可能来自 back/forward 被调用产生的行为
+        // 如果相同，不做任何行为
+        return;
+      }
+    }
+    const isRelevant = this.currentState && this.currentState.isRelevant(state);
+    this.doPushState(state, isRelevant);
+  }
+
+  get currentState() {
+    return this.stack[this.currentIndex];
+  }
+
+  doPushState(state: EditorHistoryState, isRelevant: boolean) {
+    // 如果和最新的状态关联， 则替换最新的状态
+    this.stack.splice(this.currentIndex + (isRelevant ? 0 : 1));
+    this.stack.push(state);
+    if (this.stack.length > HardMaxStateLength) {
+      this.stack.splice(0, this.stack.length - SoftMaxStateLength);
+    }
+    this.currentIndex = this.stack.length - 1;
+  }
+
+  forward() {
+    if (this.currentIndex < this.stack.length - 1) {
+      this.currentIndex++;
+      this.restoreState(this.currentState);
+    }
+  }
+
+  back() {
+    if (this.currentIndex > 0) {
+      this.currentIndex--;
+      this.restoreState(this.currentState);
+    }
+  }
+
+  restoreState(state: EditorHistoryState) {
+    if (!state) {
+      return;
+    }
+    const editorGroup = this.editorService.editorGroups[state.groupIndex] || this.editorService.currentEditorGroup;
+    editorGroup.open(state.uri, {
+      range: {
+        startColumn: state.position.column,
+        startLineNumber: state.position.lineNumber,
+        endColumn: state.position.column,
+        endLineNumber: state.position.lineNumber,
+      },
+      focus: true,
+    });
+  }
+
+  pushClosed(uri: URI) {
+    this.closedStack.push(uri);
+    if (this.closedStack.length > HardMaxStateLength) {
+      this.closedStack.splice(0, this.closedStack.length - SoftMaxStateLength);
+    }
+  }
+
+  popClosed() {
+    const uri = this.closedStack.pop();
+    if (uri) {
+      this.editorService.open(uri, {
+        focus: true,
+      });
+      this.closedStack = this.closedStack.filter((u) => !uri.isEqual(u));
+    }
+  }
+}
+
+export class EditorHistoryState {
+  constructor(
+    public readonly uri: URI,
+    public readonly position: IPosition,
+    public groupIndex: number,
+    public isTabChange: boolean,
+  ) {}
+
+  isRelevant(anotherState: EditorHistoryState): boolean {
+    if (this.uri.isEqual(anotherState.uri)) {
+      if (
+        anotherState.position.lineNumber < this.position.lineNumber + HistoryPositionLineThreshold &&
+        anotherState.position.lineNumber > this.position.lineNumber - HistoryPositionLineThreshold
+      ) {
+        return true;
+      }
+      if (this.isTabChange || anotherState.isTabChange) {
+        // 如果是 tabChange 类型，我们认为是相关的，这样防止无意义的 0 line 0 column 状态出现
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  isEqual(anotherState: EditorHistoryState) {
+    return (
+      this.uri.isEqual(anotherState.uri) &&
+      this.position.lineNumber === anotherState.position.lineNumber &&
+      this.position.column === anotherState.position.column
+    );
+  }
+}

package/src/browser/index.ts

@@ -0,0 +1,236 @@
+import { Injectable, Provider, Autowired, Injector, INJECTOR_TOKEN } from '@opensumi/di';
+import {
+  BrowserModule,
+  Domain,
+  ClientAppContribution,
+  ContributionProvider,
+  PreferenceService,
+  createPreferenceProxy,
+} from '@opensumi/ide-core-browser';
+import { ICallHierarchyService } from '@opensumi/ide-monaco/lib/browser/contrib/callHierarchy';
+import {
+  ICommandServiceToken,
+  IMonacoActionRegistry,
+  IMonacoCommandsRegistry,
+} from '@opensumi/ide-monaco/lib/browser/contrib/command';
+import { ITextmateTokenizer } from '@opensumi/ide-monaco/lib/browser/contrib/tokenizer';
+import { ITypeHierarchyService } from '@opensumi/ide-monaco/lib/browser/contrib/typeHierarchy';
+
+import { EditorCollectionService, WorkbenchEditorService, ResourceService, ILanguageService } from '../common';
+import { IDocPersistentCacheProvider } from '../common/doc-cache';
+
+import { BreadCrumbServiceImpl } from './breadcrumb';
+import { EditorComponentRegistryImpl } from './component';
+import { DefaultDiffEditorContribution } from './diff';
+import { CompareService, CompareEditorContribution } from './diff/compare';
+import { EmptyDocCacheImpl } from './doc-cache';
+import { EditorDocumentModelContentRegistryImpl, EditorDocumentModelServiceImpl } from './doc-model/main';
+import { SaveParticipantsContribution } from './doc-model/saveParticipants';
+import { IEditorDocumentModelContentRegistry, IEditorDocumentModelService } from './doc-model/types';
+import { EditorCollectionServiceImpl } from './editor-collection.service';
+import { EditorContribution, EditorAutoSaveEditorContribution } from './editor.contribution';
+import { EditorDecorationCollectionService } from './editor.decoration.service';
+import { EditorFeatureRegistryImpl } from './feature';
+import { FileSystemResourceContribution } from './fs-resource';
+import { LanguageStatusContribution } from './language/language-status.contribution';
+import { LanguageStatusService } from './language/language-status.service';
+import { LanguageService } from './language/language.service';
+import { EditorActionRegistryImpl } from './menu/editor.menu';
+import { OpenTypeMenuContribution } from './menu/open-type-menu.contribution';
+import { MergeEditorContribution } from './merge-editor/merge-editor.contribution';
+import {
+  CallHierarchyContribution,
+  CallHierarchyService,
+  TypeHierarchyService,
+  TypeHierarchyContribution,
+} from './monaco-contrib';
+import {
+  MonacoActionRegistry,
+  MonacoCommandRegistry,
+  MonacoCommandService,
+} from './monaco-contrib/command/command.service';
+import { TextmateService } from './monaco-contrib/tokenizer/textmate.service';
+import { EditorPreferenceContribution } from './preference/contribution';
+import { EditorPreferences, editorPreferenceSchema } from './preference/schema';
+import { ResourceServiceImpl } from './resource.service';
+import {
+  EditorComponentRegistry,
+  BrowserEditorContribution,
+  IEditorDecorationCollectionService,
+  IEditorActionRegistry,
+  ICompareService,
+  IBreadCrumbService,
+  IEditorFeatureRegistry,
+  ILanguageStatusService,
+} from './types';
+import { WorkbenchEditorServiceImpl } from './workbench-editor.service';
+export * from './preference/schema';
+export * from './types';
+export * from './doc-model/types';
+export * from './doc-cache';
+export * from './editor.less';
+export * from './view/editor.react';
+
+@Injectable()
+export class EditorModule extends BrowserModule {
+  providers: Provider[] = [
+    {
+      token: EditorCollectionService,
+      useClass: EditorCollectionServiceImpl,
+    },
+    {
+      token: WorkbenchEditorService,
+      useClass: WorkbenchEditorServiceImpl,
+    },
+    {
+      token: ResourceService,
+      useClass: ResourceServiceImpl,
+    },
+    {
+      token: EditorComponentRegistry,
+      useClass: EditorComponentRegistryImpl,
+    },
+    {
+      token: IEditorDecorationCollectionService,
+      useClass: EditorDecorationCollectionService,
+    },
+    {
+      token: IEditorDocumentModelContentRegistry,
+      useClass: EditorDocumentModelContentRegistryImpl,
+    },
+    {
+      token: IEditorDocumentModelService,
+      useClass: EditorDocumentModelServiceImpl,
+    },
+    {
+      token: ILanguageService,
+      useClass: LanguageService,
+    },
+    {
+      token: IEditorActionRegistry,
+      useClass: EditorActionRegistryImpl,
+    },
+    {
+      token: IDocPersistentCacheProvider,
+      useClass: EmptyDocCacheImpl,
+      // useClass: LocalStorageDocCacheImpl,
+    },
+    {
+      token: ICompareService,
+      useClass: CompareService,
+    },
+    {
+      token: IBreadCrumbService,
+      useClass: BreadCrumbServiceImpl,
+    },
+    {
+      token: IEditorFeatureRegistry,
+      useClass: EditorFeatureRegistryImpl,
+    },
+    {
+      token: EditorPreferences,
+      useFactory: (inject: Injector) => {
+        const preferences: PreferenceService = inject.get(PreferenceService);
+        return createPreferenceProxy(preferences, editorPreferenceSchema);
+      },
+    },
+    {
+      token: ICallHierarchyService,
+      useClass: CallHierarchyService,
+    },
+    {
+      token: ITypeHierarchyService,
+      useClass: TypeHierarchyService,
+    },
+    {
+      token: ICommandServiceToken,
+      useClass: MonacoCommandService,
+    },
+    {
+      token: IMonacoCommandsRegistry,
+      useClass: MonacoCommandRegistry,
+    },
+    {
+      token: IMonacoActionRegistry,
+      useClass: MonacoActionRegistry,
+    },
+    {
+      token: ITextmateTokenizer,
+      useClass: TextmateService,
+    },
+    {
+      token: ILanguageStatusService,
+      useClass: LanguageStatusService,
+    },
+    EditorPreferenceContribution,
+    DefaultDiffEditorContribution,
+    MergeEditorContribution,
+    EditorClientAppContribution,
+    EditorContribution,
+    CompareEditorContribution,
+    EditorAutoSaveEditorContribution,
+    SaveParticipantsContribution,
+    FileSystemResourceContribution,
+    CallHierarchyContribution,
+    TypeHierarchyContribution,
+    LanguageStatusContribution,
+    OpenTypeMenuContribution,
+  ];
+  contributionProvider = BrowserEditorContribution;
+}
+
+@Domain(ClientAppContribution)
+export class EditorClientAppContribution implements ClientAppContribution {
+  @Autowired()
+  resourceService!: ResourceService;
+
+  @Autowired()
+  editorComponentRegistry!: EditorComponentRegistry;
+
+  @Autowired(WorkbenchEditorService)
+  workbenchEditorService!: WorkbenchEditorServiceImpl;
+
+  @Autowired(IEditorDocumentModelContentRegistry)
+  modelContentRegistry: IEditorDocumentModelContentRegistry;
+
+  @Autowired(IEditorActionRegistry)
+  editorActionRegistry: IEditorActionRegistry;
+
+  @Autowired(IEditorFeatureRegistry)
+  editorFeatureRegistry: IEditorFeatureRegistry;
+
+  @Autowired(INJECTOR_TOKEN)
+  injector: Injector;
+
+  @Autowired(IEditorDocumentModelService)
+  modelService: EditorDocumentModelServiceImpl;
+
+  @Autowired(BrowserEditorContribution)
+  private readonly contributions: ContributionProvider<BrowserEditorContribution>;
+
+  async initialize() {
+    for (const contribution of this.contributions.getContributions()) {
+      if (contribution.registerResource) {
+        contribution.registerResource(this.resourceService);
+      }
+      if (contribution.registerEditorComponent) {
+        contribution.registerEditorComponent(this.editorComponentRegistry);
+      }
+      if (contribution.registerEditorDocumentModelContentProvider) {
+        contribution.registerEditorDocumentModelContentProvider(this.modelContentRegistry);
+      }
+      if (contribution.registerEditorActions) {
+        contribution.registerEditorActions(this.editorActionRegistry);
+      }
+      if (contribution.registerEditorFeature) {
+        contribution.registerEditorFeature(this.editorFeatureRegistry);
+      }
+    }
+    this.workbenchEditorService.contributionsReady.resolve();
+    await Promise.all([this.workbenchEditorService.initialize(), this.modelService.initialize()]);
+  }
+
+  async onDidStart() {
+    this.workbenchEditorService.prepareContextKeyService();
+  }
+}

package/src/browser/language/diagnostic-collection.ts

@@ -0,0 +1,83 @@
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import IMonacoModel = monaco.editor.IModel;
+import IMonacoMarkerData = monaco.editor.IMarkerData;
+
+// eslint-disable-next-line import/order
+import { DisposableCollection, Disposable, IDisposable } from '@opensumi/ide-core-common';
+
+// eslint-disable-next-line import/order
+import { DiagnosticCollection, Diagnostic, asMonacoDiagnostics } from '../../common';
+
+export class MonacoDiagnosticCollection implements DiagnosticCollection {
+  protected readonly diagnostics = new Map<string, MonacoModelDiagnostics | undefined>();
+  protected readonly toDispose = new DisposableCollection();
+
+  constructor(protected readonly name: string) {}
+
+  dispose() {
+    this.toDispose.dispose();
+  }
+
+  get(uri: string): Diagnostic[] {
+    const diagnostics = this.diagnostics.get(uri);
+    return diagnostics ? diagnostics.diagnostics : [];
+  }
+
+  set(uri: string, diagnostics: Diagnostic[]): void {
+    const existing = this.diagnostics.get(uri);
+    if (existing) {
+      existing.diagnostics = diagnostics;
+    } else {
+      const modelDiagnostics = new MonacoModelDiagnostics(uri, diagnostics, this.name);
+      this.diagnostics.set(uri, modelDiagnostics);
+      this.toDispose.push(
+        Disposable.create(() => {
+          this.diagnostics.delete(uri);
+          modelDiagnostics.dispose();
+        }),
+      );
+    }
+  }
+}
+
+export class MonacoModelDiagnostics implements IDisposable {
+  readonly uri: monaco.Uri;
+  protected _markers: IMonacoMarkerData[] = [];
+  protected _diagnostics: Diagnostic[] = [];
+  constructor(uri: string, diagnostics: Diagnostic[], readonly owner: string) {
+    this.uri = monaco.Uri.parse(uri);
+    this.diagnostics = diagnostics;
+    monaco.editor.onDidCreateModel((model) => this.doUpdateModelMarkers(model));
+  }
+
+  set diagnostics(diagnostics: Diagnostic[]) {
+    this._diagnostics = diagnostics;
+    this._markers = asMonacoDiagnostics(diagnostics) || [];
+    this.updateModelMarkers();
+  }
+
+  get diagnostics(): Diagnostic[] {
+    return this._diagnostics;
+  }
+
+  get markers(): ReadonlyArray<IMonacoMarkerData> {
+    return this._markers;
+  }
+
+  dispose(): void {
+    this._markers = [];
+    this.updateModelMarkers();
+  }
+
+  updateModelMarkers(): void {
+    const model = monaco.editor.getModel(this.uri);
+    this.doUpdateModelMarkers(model);
+  }
+
+  protected doUpdateModelMarkers(model: IMonacoModel | null): void {
+    if (model && this.uri.toString() === model.uri.toString()) {
+      monaco.editor.setModelMarkers(model, this.owner, this._markers);
+    }
+  }
+}

package/src/browser/language/language-status.contribution.ts

@@ -0,0 +1,81 @@
+import { Autowired } from '@opensumi/di';
+import {
+  ClientAppContribution,
+  Domain,
+  IStatusBarService,
+  localize,
+  Severity,
+  StatusBarAlignment,
+  WithEventBus,
+} from '@opensumi/ide-core-browser';
+
+import { WorkbenchEditorService, IEditor, ILanguageStatusService, ILanguageStatus } from '../../common';
+import { EditorDocumentModelOptionChangedEvent } from '../doc-model/types';
+
+@Domain(ClientAppContribution)
+export class LanguageStatusContribution extends WithEventBus implements ClientAppContribution {
+  @Autowired(IStatusBarService)
+  private readonly statusBar: IStatusBarService;
+
+  @Autowired()
+  private readonly workbenchEditorService: WorkbenchEditorService;
+
+  @Autowired(ILanguageStatusService)
+  private readonly languageStatusService: ILanguageStatusService;
+
+  initialize() {
+    this.workbenchEditorService.onActiveResourceChange(() => {
+      this.updateLanguageStatus(this.workbenchEditorService.currentEditor);
+    });
+
+    this.eventBus.on(EditorDocumentModelOptionChangedEvent, (e) => {
+      const currentEditor = this.workbenchEditorService.currentEditor;
+      if (currentEditor && currentEditor.currentUri && currentEditor.currentUri.isEqual(e.payload.uri)) {
+        this.updateLanguageStatus(this.workbenchEditorService.currentEditor);
+      }
+    });
+  }
+
+  protected updateLanguageStatus(editor: IEditor | null): void {
+    if (!editor) {
+      this.statusBar.removeElement('editor-status-language-status');
+      return;
+    }
+
+    const documentModel = editor.currentDocumentModel;
+
+    if (documentModel) {
+      const all = this.languageStatusService.getLanguageStatus(documentModel.getMonacoModel());
+      if (all.length) {
+        this.statusBar.addElement('editor-status-language-status', {
+          name: localize('status-bar.editor-langStatus'),
+          alignment: StatusBarAlignment.RIGHT,
+          text: this.getLanguageStatusText(all),
+          // 默认在选择语言模式左边
+          priority: 1.1,
+          hoverContents: all.map((status) => ({
+            title: status.label,
+            name: status.name,
+            command: status.command,
+          })),
+          // 添加个空的执行函数以便点击状态栏有相应态
+          onClick: () => {},
+        });
+      }
+    }
+  }
+  private getLanguageStatusText(status: ILanguageStatus[]) {
+    if (status.length === 0) {
+      return;
+    }
+    const [first] = status;
+    switch (first.severity) {
+      case Severity.Error:
+        return '$(bracket-error)';
+      case Severity.Warning:
+        return '$(bracket-dot)';
+      default:
+        return '$(bracket)';
+    }
+  }
+}

package/src/browser/language/language-status.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@opensumi/di';
+import { strings, Event, IDisposable } from '@opensumi/ide-core-common';
+import { LanguageFeatureRegistry } from '@opensumi/monaco-editor-core/esm/vs/editor/common/languageFeatureRegistry';
+import { ITextModel } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model';
+
+import { ILanguageStatusService, ILanguageStatus } from '../../common';
+
+const { compare } = strings;
+
+@Injectable()
+export class LanguageStatusService implements ILanguageStatusService {
+  private readonly _provider = new LanguageFeatureRegistry<ILanguageStatus>();
+
+  readonly onDidChange: Event<any> = this._provider.onDidChange;
+
+  addStatus(status: ILanguageStatus): IDisposable {
+    return this._provider.register(status.selector, status);
+  }
+
+  getLanguageStatus(model: ITextModel): ILanguageStatus[] {
+    return this._provider.ordered(model).sort((a, b) => {
+      let res = b.severity - a.severity;
+      if (res === 0) {
+        res = compare(a.source, b.source);
+      }
+      if (res === 0) {
+        res = compare(a.id, b.id);
+      }
+      return res;
+    });
+  }
+}