@opensumi/ide-editor 2.21.13 → 2.22.0

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

@@ -0,0 +1,185 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import {
+  URI,
+  IDisposable,
+  Disposable,
+  MarkerManager,
+  IMarkerData,
+  IRelatedInformation,
+  MarkerSeverity,
+} from '@opensumi/ide-core-common';
+import { ITextmateTokenizer, ITextmateTokenizerService } from '@opensumi/ide-monaco/lib/browser/contrib/tokenizer';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import {
+  DiagnosticSeverity,
+  DiagnosticRelatedInformation,
+  Diagnostic,
+  Language,
+  WorkspaceSymbolProvider,
+  ILanguageService,
+} from '../../common';
+
+import { MonacoDiagnosticCollection } from './diagnostic-collection';
+
+export type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+
+function reviveSeverity(severity: MarkerSeverity): DiagnosticSeverity {
+  switch (severity) {
+    case MarkerSeverity.Error:
+      return DiagnosticSeverity.Error;
+    case MarkerSeverity.Warning:
+      return DiagnosticSeverity.Warning;
+    case MarkerSeverity.Info:
+      return DiagnosticSeverity.Information;
+    case MarkerSeverity.Hint:
+      return DiagnosticSeverity.Hint;
+  }
+}
+
+function reviveRange(startLine: number, startColumn: number, endLine: number, endColumn: number): any {
+  // note: language server range is 0-based, marker is 1-based, so need to deduct 1 here
+  return {
+    start: {
+      line: startLine - 1,
+      character: startColumn - 1,
+    },
+    end: {
+      line: endLine - 1,
+      character: endColumn - 1,
+    },
+  };
+}
+
+function reviveRelated(related: IRelatedInformation): DiagnosticRelatedInformation {
+  return {
+    message: related.message,
+    location: {
+      uri: related.resource,
+      range: reviveRange(related.startLineNumber, related.startColumn, related.endLineNumber, related.endColumn),
+    },
+  };
+}
+
+export function reviveMarker(marker: IMarkerData): Diagnostic {
+  const monacoMarker: Diagnostic = {
+    code:
+      typeof marker.codeHref !== 'undefined'
+        ? {
+            value: String(marker.code),
+            target: marker.codeHref.codeUri,
+          }
+        : marker.code,
+    severity: reviveSeverity(marker.severity) as any,
+    range: reviveRange(marker.startLineNumber, marker.startColumn, marker.endLineNumber, marker.endColumn),
+    message: marker.message,
+    source: marker.source,
+    relatedInformation: undefined,
+    tags: marker.tags as number[],
+  };
+
+  if (marker.relatedInformation) {
+    monacoMarker.relatedInformation = marker.relatedInformation.map(reviveRelated);
+  }
+
+  return monacoMarker;
+}
+
+@Injectable()
+export class LanguageService implements ILanguageService {
+  @Autowired()
+  private markerManager: MarkerManager;
+
+  @Autowired(ITextmateTokenizer)
+  private textmateService: ITextmateTokenizerService;
+
+  protected readonly markers = new Map<string, MonacoDiagnosticCollection>();
+
+  readonly workspaceSymbolProviders: WorkspaceSymbolProvider[] = [];
+
+  constructor() {
+    for (const uri of this.markerManager.getResources()) {
+      this.updateMarkers(new URI(uri));
+    }
+    this.markerManager.onMarkerChanged((uris) => {
+      if (uris) {
+        uris.forEach((uri) => this.updateMarkers(new URI(uri)));
+      }
+    });
+  }
+
+  get languages(): Language[] {
+    return [...this.mergeLanguages(this.textmateService.getLanguages()).values()];
+  }
+
+  getLanguage(languageId: string): Language | undefined {
+    return this.mergeLanguages(
+      this.textmateService.getLanguages().filter((language) => language.id === languageId),
+    ).get(languageId);
+  }
+
+  protected mergeLanguages(registered: monaco.languages.ILanguageExtensionPoint[]): Map<string, Mutable<Language>> {
+    const languages = new Map<string, Mutable<Language>>();
+    for (const { id, aliases, extensions, filenames } of registered) {
+      const merged = languages.get(id) || {
+        id,
+        name: '',
+        extensions: new Set(),
+        filenames: new Set(),
+      };
+      if (!merged.name && aliases && aliases.length) {
+        merged.name = aliases[0];
+      }
+      if (extensions && extensions.length) {
+        for (const extension of extensions) {
+          merged.extensions.add(extension);
+        }
+      }
+      if (filenames && filenames.length) {
+        for (const filename of filenames) {
+          merged.filenames.add(filename);
+        }
+      }
+      languages.set(id, merged);
+    }
+    for (const [id, language] of languages) {
+      if (!language.name) {
+        language.name = id;
+      }
+    }
+    return languages;
+  }
+
+  registerWorkspaceSymbolProvider(provider: WorkspaceSymbolProvider): IDisposable {
+    this.workspaceSymbolProviders.push(provider);
+    return Disposable.create(() => {
+      const index = this.workspaceSymbolProviders.indexOf(provider);
+      if (index !== -1) {
+        this.workspaceSymbolProviders.splice(index, 1);
+      }
+    });
+  }
+
+  protected updateMarkers(uri: URI): void {
+    const uriString = uri.toString();
+    const owners = new Map<string, Diagnostic[]>();
+    for (const marker of this.markerManager.getMarkers({ resource: uri.toString() })) {
+      const diagnostics = owners.get(marker.type) || [];
+      diagnostics.push(reviveMarker(marker));
+      owners.set(marker.type, diagnostics);
+    }
+    const toClean = new Set<string>(this.markers.keys());
+    for (const [owner, diagnostics] of owners) {
+      toClean.delete(owner);
+      const collection = this.markers.get(owner) || new MonacoDiagnosticCollection(owner);
+      collection.set(uriString, diagnostics);
+      this.markers.set(owner, collection);
+    }
+    for (const owner of toClean) {
+      const collection = this.markers.get(owner);
+      if (collection) {
+        collection.set(uriString, []);
+      }
+    }
+  }
+}

package/src/browser/menu/editor.context.ts

@@ -0,0 +1,186 @@
+import { Disposable, IContextKeyService } from '@opensumi/ide-core-browser';
+import { AbstractContextMenuService, MenuId, ICtxMenuRenderer } from '@opensumi/ide-core-browser/lib/menu/next';
+import { ICodeEditor } from '@opensumi/ide-monaco/lib/common/types';
+import * as dom from '@opensumi/monaco-editor-core/esm/vs/base/browser/dom';
+import { IAnchor } from '@opensumi/monaco-editor-core/esm/vs/base/browser/ui/contextview/contextview';
+import { KeyCode } from '@opensumi/monaco-editor-core/esm/vs/base/common/keyCodes';
+import { IEditorMouseEvent, MouseTargetType } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import { EditorOption } from '@opensumi/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
+import { IEditorContribution } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';
+import { ContextMenuController } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/contextmenu/browser/contextmenu';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+export class EditorContextMenuController extends Disposable implements IEditorContribution {
+  public static readonly ID = 'editor.contrib.contextmenu';
+
+  public static get(editor: ICodeEditor): ContextMenuController | null {
+    return editor.getContribution<ContextMenuController>(ContextMenuController.ID);
+  }
+
+  private readonly contextKeyService: IContextKeyService;
+
+  constructor(
+    private readonly contextMenuService: AbstractContextMenuService,
+    private readonly globalContextKeyService: IContextKeyService,
+    private readonly contextMenuRenderer: ICtxMenuRenderer,
+    private codeEditor: ICodeEditor,
+  ) {
+    super();
+    this.contextKeyService = this.registerDispose(
+      this.globalContextKeyService.createScoped((this.codeEditor as any)._contextKeyService),
+    );
+    this.addDispose(this.codeEditor.onContextMenu((e) => this.onContextMenu(e)));
+    this.addDispose(
+      this.codeEditor.onKeyDown((e) => {
+        if (e.keyCode === KeyCode.ContextMenu) {
+          e.preventDefault();
+          e.stopPropagation();
+          this.showContextMenu();
+        }
+      }),
+    );
+  }
+
+  showContextMenu(anchor?: IAnchor | null): void {
+    if (!this.codeEditor.getOption(EditorOption.contextmenu)) {
+      return; // Context menu is turned off through configuration
+    }
+    if (!this.codeEditor.hasModel()) {
+      return;
+    }
+
+    if (!this.contextMenuService) {
+      this.codeEditor.focus();
+      return; // We need the context menu service to function
+    }
+
+    // Find actions available for menu
+    const menuNodes = this.getMenuNodes();
+    // Show menu if we have actions to show
+    if (menuNodes.length > 0) {
+      this._doShowContextMenu(menuNodes, anchor);
+    }
+  }
+
+  // ref: https://github.com/microsoft/vscode/blob/1498d0f34053f854e75e1364adaca6f99e43de08/src/vs/editor/contrib/contextmenu/browser/contextmenu.ts
+  private onContextMenu(e: IEditorMouseEvent) {
+    if (!this.codeEditor.hasModel()) {
+      return;
+    }
+
+    if (!this.codeEditor.getOption(EditorOption.contextmenu)) {
+      this.codeEditor.focus();
+      // Ensure the cursor is at the position of the mouse click
+      if (e.target.position && !this.codeEditor.getSelection().containsPosition(e.target.position)) {
+        this.codeEditor.setPosition(e.target.position);
+      }
+      return; // Context menu is turned off through configuration
+    }
+
+    if (e.target.type === MouseTargetType.OVERLAY_WIDGET) {
+      return; // allow native menu on widgets to support right click on input field for example in find
+    }
+    if (e.target.type === MouseTargetType.CONTENT_TEXT && e.target.detail.injectedText) {
+      return; // allow native menu on injected text
+    }
+
+    e.event.preventDefault();
+    e.event.stopPropagation();
+
+    if (
+      e.target.type !== MouseTargetType.CONTENT_TEXT &&
+      e.target.type !== MouseTargetType.CONTENT_EMPTY &&
+      e.target.type !== MouseTargetType.TEXTAREA
+    ) {
+      return; // only support mouse click into text or native context menu key for now
+    }
+
+    // Ensure the editor gets focus if it hasn't, so the right events are being sent to other contributions
+    this.codeEditor.focus();
+
+    // Ensure the cursor is at the position of the mouse click
+    if (e.target.position) {
+      let hasSelectionAtPosition = false;
+      for (const selection of this.codeEditor.getSelections()) {
+        if (selection.containsPosition(e.target.position)) {
+          hasSelectionAtPosition = true;
+          break;
+        }
+      }
+
+      if (!hasSelectionAtPosition) {
+        this.codeEditor.setPosition(e.target.position);
+      }
+    }
+
+    // Unless the user triggerd the context menu through Shift+F10, use the mouse position as menu position
+    let anchor: IAnchor | null = null;
+    if (e.target.type !== MouseTargetType.TEXTAREA) {
+      anchor = { x: e.event.posx - 1, width: 2, y: e.event.posy - 1, height: 2 };
+    }
+
+    // Show the context menu
+    this.showContextMenu(anchor);
+  }
+
+  private _doShowContextMenu(menuNodes: any[], anchor?: IAnchor | null) {
+    const editor = this.codeEditor;
+    // https://github.com/microsoft/vscode/blob/master/src/vs/editor/contrib/contextmenu/contextmenu.ts#L196
+    if (!editor.hasModel()) {
+      return;
+    }
+
+    // Disable hover
+    const oldHoverSetting = editor.getOption(monaco.editor.EditorOption.hover);
+    editor.updateOptions({
+      hover: {
+        enabled: false,
+      },
+    });
+
+    if (!anchor) {
+      // Ensure selection is visible
+      editor.revealPosition(editor.getPosition(), monaco.editor.ScrollType.Immediate);
+
+      editor.render();
+      const cursorCoords = editor.getScrolledVisiblePosition(editor.getPosition());
+
+      // Translate to absolute editor position
+      const editorCoords = dom.getDomNodePagePosition(editor.getDomNode());
+      const posx = editorCoords.left + cursorCoords.left;
+      const posy = editorCoords.top + cursorCoords.top + cursorCoords.height;
+
+      anchor = { x: posx, y: posy };
+    }
+
+    // Show the context menu
+    this.contextMenuRenderer.show({
+      anchor: {
+        x: anchor.x - window.scrollX,
+        y: anchor.y - window.scrollY,
+      },
+      menuNodes,
+      args: [editor.getModel().uri],
+      onHide: () => {
+        // 无论是否取消都应该恢复 hover 的设置
+        this.codeEditor.updateOptions({
+          hover: oldHoverSetting,
+        });
+
+        // 右键菜单关闭后应该使编辑器重新 focus
+        // 原因是一些内置的 command (copy/cut/paste) 在执行时会在对应的 focusedEditor 执行，如果找不到 focusedEditor 则不会执行命令
+        this.codeEditor.focus();
+      },
+    });
+  }
+
+  private getMenuNodes() {
+    const contextMenu = this.contextMenuService.createMenu({
+      id: MenuId.EditorContext,
+      contextKeyService: this.contextKeyService,
+    });
+    const menuNodes = contextMenu.getMergedMenuNodes();
+    contextMenu.dispose();
+    return menuNodes;
+  }
+}

package/src/browser/menu/editor.menu.ts

@@ -0,0 +1,45 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { IDisposable, Disposable, IContextKeyService, ILogger } from '@opensumi/ide-core-browser';
+import { MenuId, AbstractContextMenuService, IContextMenu } from '@opensumi/ide-core-browser/lib/menu/next';
+
+import { IEditorGroup } from '../../common';
+import { IEditorActionRegistry } from '../types';
+import { EditorGroup } from '../workbench-editor.service';
+
+@Injectable()
+export class EditorActionRegistryImpl extends Disposable implements IEditorActionRegistry {
+  private _cachedMenus = new Map<string, IContextMenu>();
+
+  @Autowired(IContextKeyService)
+  private contextKeyService: IContextKeyService;
+
+  @Autowired(AbstractContextMenuService)
+  private readonly menuService: AbstractContextMenuService;
+
+  @Autowired(ILogger)
+  logger: ILogger;
+
+  registerEditorAction(): IDisposable {
+    this.logger.warn(new Error('registerEditorAction has been deprecated, use menu apis instead'));
+    return new Disposable();
+  }
+
+  getMenu(group: IEditorGroup): IContextMenu {
+    const key = group.currentFocusedEditor
+      ? 'editor-menu-' + group.currentFocusedEditor.getId()
+      : 'editor-group-menu-' + group.name;
+    if (!this._cachedMenus.has(key)) {
+      const contextKeyService = group.currentFocusedEditor
+        ? this.contextKeyService.createScoped((group.currentFocusedEditor.monacoEditor as any)._contextKeyService)
+        : (group as EditorGroup).contextKeyService;
+      const menus = this.registerDispose(
+        this.menuService.createMenu({
+          id: MenuId.EditorTitle,
+          contextKeyService,
+        }),
+      );
+      this._cachedMenus.set(key, menus);
+    }
+    return this._cachedMenus.get(key)!;
+  }
+}

package/src/browser/menu/open-type-menu.contribution.ts

@@ -0,0 +1,90 @@
+import { Autowired } from '@opensumi/di';
+import { getIcon } from '@opensumi/ide-core-browser';
+import {
+  IMenuRegistry,
+  ISubmenuItem,
+  MenuId,
+  MenuContribution,
+  IMenuItem,
+  MenuCommandDesc,
+} from '@opensumi/ide-core-browser/lib/menu/next';
+import { Command, CommandContribution, CommandRegistry, Disposable, localize } from '@opensumi/ide-core-common';
+import { Domain } from '@opensumi/ide-core-common/lib/di-helper';
+
+import { WorkbenchEditorService } from '../types';
+
+import { IEditorOpenType } from './../../common/editor';
+import { WorkbenchEditorServiceImpl } from './../workbench-editor.service';
+
+namespace OPEN_TYPE_COMMANDS {
+  export const EDITOR_OPEN_TYPE: Command = {
+    id: 'editor.opentype',
+  };
+}
+
+@Domain(CommandContribution, MenuContribution)
+export class OpenTypeMenuContribution extends Disposable implements CommandContribution, MenuContribution {
+  @Autowired(WorkbenchEditorService)
+  private readonly workbenchEditorService: WorkbenchEditorServiceImpl;
+
+  @Autowired(IMenuRegistry)
+  private readonly menuRegistry: IMenuRegistry;
+
+  registerCommands(commands: CommandRegistry): void {
+    commands.registerCommand(OPEN_TYPE_COMMANDS.EDITOR_OPEN_TYPE, {
+      execute: (id: string) => {
+        if (id) {
+          this.workbenchEditorService.currentEditorGroup.changeOpenType(id);
+        }
+      },
+    });
+  }
+
+  constructor() {
+    super();
+    this.disposables.push(
+      this.workbenchEditorService.onActiveResourceChange((e) => {
+        const openTypes = this.workbenchEditorService.currentEditorGroup.availableOpenTypes;
+        // 如果打开方式没有两个以上，则不需要展示
+        const preMenu = this.menuRegistry
+          .getMenuItems(MenuId.OpenTypeSubmenuContext)
+          .map((e) => (e as IMenuItem).command as MenuCommandDesc);
+        preMenu.forEach((c) => {
+          this.menuRegistry.unregisterMenuItem(MenuId.OpenTypeSubmenuContext, c.id);
+        });
+
+        this.menuRegistry.unregisterMenuItem(MenuId.EditorTitle, MenuId.OpenTypeSubmenuContext);
+
+        if (openTypes.length >= 2) {
+          this.registerMenuItem(openTypes);
+        }
+      }),
+    );
+  }
+
+  registerMenus(menuRegistry: IMenuRegistry) {}
+
+  private registerMenuItem(openTypes: IEditorOpenType[]) {
+    const openTypeMenus = {
+      submenu: MenuId.OpenTypeSubmenuContext,
+      label: localize('editor.openType'),
+      group: 'navigation',
+      order: Number.MIN_SAFE_INTEGER,
+      iconClass: getIcon('setting'),
+      type: 'default',
+    } as ISubmenuItem;
+
+    this.menuRegistry.registerMenuItem(MenuId.EditorTitle, openTypeMenus);
+
+    openTypes.forEach((type) => {
+      this.menuRegistry.registerMenuItem(MenuId.OpenTypeSubmenuContext, {
+        command: {
+          id: OPEN_TYPE_COMMANDS.EDITOR_OPEN_TYPE.id,
+          label: type.title || type.componentId || type.type,
+        },
+        extraTailArgs: [type.componentId ?? type.type],
+        group: 'navigation',
+      });
+    });
+  }
+}

package/src/browser/menu/title-context.menu.ts

@@ -0,0 +1,54 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { IContextKeyService } from '@opensumi/ide-core-browser';
+import { ResourceContextKey } from '@opensumi/ide-core-browser/lib/contextkey/resource';
+import { AbstractContextMenuService, ICtxMenuRenderer, MenuId } from '@opensumi/ide-core-browser/lib/menu/next';
+import { URI } from '@opensumi/ide-core-common';
+
+import { IEditorGroup } from '../../common';
+import { EditorGroup } from '../workbench-editor.service';
+
+@Injectable()
+export class TabTitleMenuService {
+  @Autowired(AbstractContextMenuService)
+  ctxMenuService: AbstractContextMenuService;
+
+  @Autowired(ICtxMenuRenderer)
+  ctxMenuRenderer: ICtxMenuRenderer;
+
+  @Autowired(IContextKeyService)
+  contextKeyService: IContextKeyService;
+
+  private _editorTitleContextKey;
+
+  private get editorTitleContextKey() {
+    if (!this._editorTitleContextKey) {
+      this._editorTitleContextKey = this.contextKeyService.createKey('editorTitleContext', false);
+    }
+    return this._editorTitleContextKey;
+  }
+
+  show(x: number, y: number, uri: URI, group: IEditorGroup) {
+    // 设置resourceScheme
+    const titleContext = (group as EditorGroup).contextKeyService.createScoped();
+    const resourceContext = new ResourceContextKey(titleContext);
+    resourceContext.set(uri);
+    this.editorTitleContextKey.set(true);
+
+    const menus = this.ctxMenuService.createMenu({
+      id: MenuId.EditorTitleContext,
+      contextKeyService: titleContext,
+    });
+    const menuNodes = menus.getMergedMenuNodes();
+    menus.dispose();
+    titleContext.dispose();
+
+    this.ctxMenuRenderer.show({
+      anchor: { x, y },
+      menuNodes,
+      args: [{ uri, group }],
+      onHide: () => {
+        this.editorTitleContextKey.set(false);
+      },
+    });
+  }
+}

package/src/browser/merge-editor/merge-editor.contribution.ts

@@ -0,0 +1,25 @@
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-browser';
+
+import { ResourceService } from '../../common';
+import { BrowserEditorContribution, EditorComponentRegistry, EditorOpenType } from '../types';
+
+import { MergeEditorResourceProvider } from './merge-editor.provider';
+
+@Domain(BrowserEditorContribution)
+export class MergeEditorContribution implements BrowserEditorContribution {
+  @Autowired()
+  private readonly mergeEditorResourceProvider: MergeEditorResourceProvider;
+
+  registerResource(resourceService: ResourceService): void {
+    resourceService.registerResourceProvider(this.mergeEditorResourceProvider);
+  }
+
+  registerEditorComponent(registry: EditorComponentRegistry) {
+    registry.registerEditorComponentResolver('mergeEditor', (_, results) => {
+      results.push({
+        type: EditorOpenType.mergeEditor,
+      });
+    });
+  }
+}

package/src/browser/merge-editor/merge-editor.provider.ts

@@ -0,0 +1,36 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, WithEventBus, MaybePromise, LabelService } from '@opensumi/ide-core-browser';
+
+import { IResourceProvider, IResource } from '../../common';
+
+@Injectable()
+export class MergeEditorResourceProvider extends WithEventBus implements IResourceProvider {
+  scheme = 'mergeEditor';
+
+  @Autowired(LabelService)
+  private readonly labelService: LabelService;
+
+  public provideResource(uri: URI): MaybePromise<IResource<any>> {
+    const { openMetadata, name } = uri.getParsedQuery();
+
+    try {
+      const parseMetaData = JSON.parse(openMetadata);
+      const { ancestor, input1, input2, output } = parseMetaData;
+      const resultEditorUri = new URI(output);
+      const icon = this.labelService.getIcon(resultEditorUri);
+      return {
+        name,
+        icon,
+        uri,
+        metadata: {
+          ancestor,
+          input1,
+          input2,
+          output,
+        },
+      };
+    } catch (error) {
+      throw Error('invalid merge editor resource parse');
+    }
+  }
+}