@opensumi/ide-core-browser 2.21.13 → 2.22.0

package/src/menu/next/renderer/ctxmenu/electron.ts

@@ -0,0 +1,207 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { INativeMenuTemplate, CommandService, IElectronMainMenuService } from '@opensumi/ide-core-common';
+import { strings, Disposable } from '@opensumi/ide-core-common';
+
+import { SpecialCases } from '../../../../keyboard';
+import { electronEnv } from '../../../../utils';
+import { MenuNode } from '../../base';
+import { SeparatorMenuItemNode, SubmenuItemNode, AbstractContextMenuService } from '../../menu.interface';
+import { AbstractMenubarService } from '../../menubar-service';
+
+import { CtxMenuRenderParams, ICtxMenuRenderer } from './base';
+
+export abstract class IElectronCtxMenuRenderer extends ICtxMenuRenderer {}
+
+export const IElectronMenuFactory = Symbol('IElectronMenuFactory');
+
+export const IElectronMenuBarService = Symbol('IElectronMenuBarService');
+
+export interface IElectronMenuBarService {
+  start();
+}
+
+@Injectable()
+export class ElectronMenuFactory extends Disposable {
+  public getTemplate(
+    menuNodes: MenuNode[],
+    menuMap: Map<string, () => void>,
+    context?: any[],
+  ): INativeMenuTemplate[] | undefined {
+    return menuNodes.map((menuNode, index) => {
+      if (menuNode.id === SeparatorMenuItemNode.ID) {
+        return { type: 'separator' };
+      }
+      if (menuNode.id === SubmenuItemNode.ID) {
+        const submenuTemplate = this.getTemplate(menuNode.children, menuMap, context);
+        return {
+          label: `${strings.mnemonicButtonLabel(menuNode.label, true)}`,
+          submenu: Array.isArray(submenuTemplate) && submenuTemplate.length ? submenuTemplate : undefined,
+        };
+      } else {
+        this.bindAction(menuNode, menuMap, index, context);
+        return {
+          type: menuNode.checked ? 'checkbox' : undefined,
+          checked: menuNode.checked ? menuNode.checked : false,
+          label: `${strings.mnemonicButtonLabel(menuNode.label, true)} ${
+            menuNode.isKeyCombination ? menuNode.keybinding : ''
+          }`,
+          id: `${menuNode.id}-${index}`,
+          action: true,
+          role: menuNode.nativeRole,
+          disabled: menuNode.disabled,
+          accelerator:
+            menuNode.rawKeybinding && !menuNode.isKeyCombination
+              ? toElectronAccelerator(menuNode.rawKeybinding)
+              : undefined,
+        };
+      }
+    });
+  }
+
+  private bindAction(menuNode: MenuNode, map: Map<string, () => void>, index: number, context?: any[]) {
+    if (typeof menuNode.execute === 'function') {
+      map.set(`${menuNode.id}-${index}`, () => {
+        menuNode.execute(context);
+      });
+    }
+  }
+}
+
+@Injectable()
+export class ElectronCtxMenuRenderer implements IElectronCtxMenuRenderer {
+  private contextMenuActions = new Map<string, () => void>();
+
+  @Autowired(CommandService) protected readonly commandService: CommandService;
+
+  @Autowired(IElectronMainMenuService)
+  private electronMainMenuService: IElectronMainMenuService;
+
+  @Autowired(IElectronMenuFactory)
+  factory: ElectronMenuFactory;
+
+  @Autowired(AbstractContextMenuService)
+  private readonly menuService: AbstractContextMenuService;
+
+  public show(payload: CtxMenuRenderParams) {
+    const { onHide, args: context } = payload;
+
+    let menuNodes: MenuNode[];
+    if (typeof payload.menuNodes === 'string') {
+      const menus = this.menuService.createMenu({
+        id: payload.menuNodes,
+        config: {
+          args: payload.args,
+        },
+        contextKeyService: payload.contextKeyService,
+      });
+      menuNodes = menus.getMergedMenuNodes();
+      menus.dispose();
+    } else {
+      menuNodes = payload.menuNodes;
+    }
+
+    // bind actions in this context
+    this.contextMenuActions.clear();
+    const template = this.factory.getTemplate(menuNodes, this.contextMenuActions, context);
+    this.createNativeContextMenu({ submenu: template }, onHide);
+  }
+
+  createNativeContextMenu(template: INativeMenuTemplate, onHide?: (canceled) => void) {
+    this.electronMainMenuService.showContextMenu(template, electronEnv.currentWebContentsId);
+    const disposer = new Disposable();
+    disposer.addDispose(
+      this.electronMainMenuService.on('menuClose', (targetId, contextMenuId) => {
+        if (targetId !== electronEnv.currentWebContentsId + '-context') {
+          return;
+        }
+        disposer.dispose();
+        if (onHide) {
+          onHide(true);
+        }
+      }),
+    );
+
+    disposer.addDispose(
+      this.electronMainMenuService.on('menuClick', (targetId, menuId) => {
+        if (targetId !== electronEnv.currentWebContentsId + '-context') {
+          return;
+        }
+        const action = this.contextMenuActions.get(menuId);
+        if (action) {
+          action();
+        }
+        if (onHide) {
+          onHide(false);
+        }
+        disposer.dispose();
+      }),
+    );
+  }
+}
+
+function toElectronAccelerator(keybinding: string) {
+  return keybinding
+    .replace('ctrlcmd', 'CmdOrCtrl')
+    .replace(SpecialCases.MACMETA, 'CmdOrCtrl')
+    .replace(SpecialCases.CTRL, 'Ctrl')
+    .replace(SpecialCases.SHIFT, 'Shift')
+    .replace(SpecialCases.ALT, 'Alt');
+}
+
+@Injectable()
+export class ElectronMenuBarService implements IElectronMenuBarService {
+  private menuBarActions = new Map<string, () => void>();
+
+  @Autowired(CommandService) protected readonly commandService: CommandService;
+
+  @Autowired(AbstractMenubarService)
+  menubarService: AbstractMenubarService;
+
+  @Autowired(IElectronMainMenuService)
+  private electronMainMenuService: IElectronMainMenuService;
+
+  @Autowired(IElectronMenuFactory)
+  factory: ElectronMenuFactory;
+
+  start() {
+    this.electronMainMenuService.on('menuClick', (targetId, menuId) => {
+      if (targetId !== electronEnv.currentWindowId + '-app') {
+        return;
+      }
+      const action = this.menuBarActions.get(menuId);
+      if (action) {
+        action();
+      }
+    });
+    this.updateMenuBar();
+    // 同时监听 onDidMenuBarChange/onDidMenuChange
+    this.menubarService.onDidMenubarChange(() => {
+      this.updateMenuBar();
+    });
+    this.menubarService.onDidMenuChange(() => {
+      this.updateMenuBar();
+    });
+  }
+
+  updateMenuBar() {
+    this.menuBarActions.clear();
+    const menubarItems = this.menubarService.getMenubarItems();
+    const appMenuTemplate: INativeMenuTemplate[] = [];
+    menubarItems.forEach((item) => {
+      const menuId = item.id;
+      const menuNodes = this.menubarService.getMenuNodes(menuId);
+      const templates = this.factory.getTemplate(menuNodes, this.menuBarActions);
+      if (templates && templates.length > 0) {
+        const template: INativeMenuTemplate = {
+          label: strings.mnemonicButtonLabel(item.label, true),
+          submenu: templates,
+        };
+        if (item.nativeRole) {
+          template.role = item.nativeRole;
+        }
+        appMenuTemplate.push(template);
+      }
+    });
+    this.electronMainMenuService.setApplicationMenu({ submenu: appMenuTemplate }, electronEnv.currentWindowId);
+  }
+}

package/src/menu/next/toolbar-action.service.ts

@@ -0,0 +1,132 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { IDisposable, Disposable } from '@opensumi/ide-core-common';
+
+import { IToolbarRegistry, createToolbarActionBtn } from '../../toolbar';
+import { createToolbarActionSelect } from '../../toolbar/components/select';
+
+interface IDescriptor {
+  title: string;
+  description?: string;
+}
+
+/**
+ * @deprecated
+ */
+interface IToolbarAction extends IDescriptor {
+  type: 'action';
+  click: (args: any) => void;
+  iconClass: string;
+}
+
+/**
+ * @deprecated
+ */
+interface IToolbarSelect extends IDescriptor {
+  type: 'enum';
+  select: (value: string) => void;
+  enum: string[];
+  defaultValue?: string;
+}
+
+/**
+ * @deprecated
+ */
+export type IToolbarActionGroup = Array<IToolbarAction | IToolbarSelect>;
+
+/**
+ * @deprecated
+ */
+export const IToolbarActionService = Symbol('IToolBarActionsService');
+
+/**
+ * @deprecated 使用 IToolbarRegistry 执行相关能力
+ */
+export interface IToolbarActionService {
+  registryActionGroup(id: string, groups: IToolbarActionGroup): IDisposable;
+  unRegistryActionGroup(id: string): void;
+}
+
+/**
+ * @deprecated 使用 IToolbarRegistry 执行相关能力
+ */
+@Injectable()
+export class ToolbarActionService extends Disposable implements IToolbarActionService {
+  private groups = new Map<string, IDisposable>();
+
+  @Autowired(IToolbarRegistry)
+  registry: IToolbarRegistry;
+
+  constructor() {
+    super();
+  }
+
+  public registryActionGroup(id: string, group: IToolbarActionGroup): IDisposable {
+    const disposer = new Disposable();
+
+    disposer.addDispose(
+      this.registry.registerToolbarActionGroup({
+        id,
+        preferredLocation: 'menu-right',
+      }),
+    );
+
+    disposer.addDispose({
+      dispose: () => {
+        this.groups.delete(id);
+      },
+    });
+
+    group.forEach((item, i) => {
+      const actionId = id + '-action-' + i;
+      if (item.type === 'action') {
+        disposer.addDispose(
+          this.registry.registerToolbarAction({
+            id: actionId,
+            description: item.description || actionId,
+            component: createToolbarActionBtn({
+              iconClass: item.iconClass!,
+              title: item.title,
+              id: actionId,
+              delegate: (delegate) => {
+                if (delegate) {
+                  delegate.onClick(item.click);
+                }
+              },
+            }),
+            preferredPosition: {
+              group: id,
+            },
+          }),
+        );
+      } else if (item.type === 'enum') {
+        disposer.addDispose(
+          this.registry.registerToolbarAction({
+            id: actionId,
+            description: item.description || actionId,
+            component: createToolbarActionSelect({
+              defaultValue: item.defaultValue || item.title,
+              options: item.enum.map((e) => ({
+                label: e,
+                value: e,
+              })),
+              onSelect: (value) => item.select(value),
+            }),
+            preferredPosition: {
+              group: id,
+            },
+          }),
+        );
+      }
+    });
+
+    this.groups.set(id, disposer);
+
+    return disposer;
+  }
+
+  public unRegistryActionGroup(id: string) {
+    if (this.groups.has(id)) {
+      this.groups.get(id)!.dispose;
+    }
+  }
+}

package/src/monaco/index.ts

@@ -0,0 +1,136 @@
+import { IJSONSchema, Event, IDisposable, BasicEvent } from '@opensumi/ide-core-common';
+import type { ICodeEditor, IDiffEditor } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import type { IDiffEditorConstructionOptions } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import type { IEditorContribution } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';
+import type {
+  DocumentFormattingEditProvider,
+  DocumentRangeFormattingEditProvider,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/common/languages';
+import type { ITextModel } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model';
+import type { IFormattingEditProviderSelector } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/format/browser/format';
+import type {
+  ISelectedSuggestion,
+  SuggestWidget,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/suggest/browser/suggestWidget';
+import type { IStandaloneEditorConstructionOptions } from '@opensumi/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
+import type { BrandedService } from '@opensumi/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+
+import { IMergeEditorEditor } from './merge-editor-widget';
+
+export enum ServiceNames {
+  CODE_EDITOR_SERVICE = 'codeEditorService',
+  TEXT_MODEL_SERVICE = 'textModelService',
+  CONTEXT_VIEW_SERVICE = 'contextViewService',
+  COMMAND_SERVICE = 'commandService',
+  CONTEXT_KEY_SERVICE = 'contextKeyService',
+  BULK_EDIT_SERVICE = 'IWorkspaceEditService',
+  OPENER_SERVICE = 'openerService',
+}
+
+export abstract class MonacoService {
+  public abstract createCodeEditor(
+    monacoContainer: HTMLElement,
+    options?: IStandaloneEditorConstructionOptions,
+    overrides?: { [key: string]: any },
+  ): ICodeEditor;
+
+  public abstract createDiffEditor(
+    monacoContainer: HTMLElement,
+    options?: IDiffEditorConstructionOptions,
+    overrides?: { [key: string]: any },
+  ): IDiffEditor;
+
+  public abstract createMergeEditor(
+    monacoContainer: HTMLElement,
+    options?: IDiffEditorConstructionOptions,
+    overrides?: { [key: string]: any },
+  ): IMergeEditorEditor;
+
+  public abstract registerOverride(serviceName: ServiceNames, service: any): void;
+
+  public abstract testTokenize(text: string, languageId: string): void;
+
+  public abstract getOverride(serviceName: ServiceNames): any;
+}
+
+export abstract class MonacoOverrideServiceRegistry {
+  abstract registerOverrideService(serviceId: ServiceNames, service: any): void;
+
+  abstract getRegisteredService<S>(serviceId: ServiceNames): S | undefined;
+
+  abstract all(): { [serviceId: string]: any };
+}
+
+export const MonacoContribution = Symbol('MonacoContribution');
+
+export type FormattingSelectorType = (
+  formatters: Array<DocumentFormattingEditProvider | DocumentRangeFormattingEditProvider>,
+  document: ITextModel,
+) => DocumentFormattingEditProvider | DocumentRangeFormattingEditProvider;
+
+export interface MonacoContribution {
+  registerOverrideService?(registry: MonacoOverrideServiceRegistry): void;
+
+  registerMonacoDefaultFormattingSelector?(registry: (selector: IFormattingEditProviderSelector) => void): void;
+
+  registerEditorExtensionContribution?<Services extends BrandedService[]>(
+    register: (
+      id: string,
+      contribCtor: new (editor: ICodeEditor, ...services: Services) => IEditorContribution,
+    ) => void,
+  ): void;
+
+  /**
+   * [{ id: association.id, mime: mimetype, filepattern: association.filePattern }]
+   * @param register
+   */
+  registerPlatformLanguageAssociations?(register: (mime: MimeAssociation[]) => void): void;
+}
+
+export const Extensions = {
+  JSONContribution: 'base.contributions.json',
+};
+
+export interface ISchemaContributions {
+  schemas: { [id: string]: IJSONSchema };
+}
+
+export interface IJSONSchemaRegistry {
+  readonly onDidChangeSchema: Event<string>;
+
+  registerSchema(uri: string, unresolvedSchemaContent: IJSONSchema, fileMatch: string[]): void;
+
+  notifySchemaChanged(uri: string): void;
+
+  getSchemaContributions(): ISchemaContributions;
+}
+
+export const IJSONSchemaRegistry = Symbol('IJSONSchemaRegistry');
+
+export const JsonSchemaContribution = Symbol('JsonSchemaContribution');
+export interface JsonSchemaContribution {
+  registerSchema(registry: IJSONSchemaRegistry): void;
+}
+export interface JsonSchemaConfiguration {
+  url: string;
+  fileMatch: string[];
+}
+export interface ISchemaStore {
+  onSchemasChanged: Event<void>;
+  register(config: JsonSchemaConfiguration): IDisposable;
+  getConfigurations(): JsonSchemaConfiguration[];
+}
+
+export const ISchemaStore = Symbol('ISchemaStore');
+
+export interface MimeAssociation {
+  readonly id: string;
+  readonly filepattern: string;
+  readonly mime: string;
+}
+
+export interface SuggestEventPayload {
+  eventType: 'onDidSelect' | 'onDidHide' | 'onDidShow' | 'onDidFocus';
+  data: ISelectedSuggestion | SuggestWidget;
+}
+export class SuggestEvent extends BasicEvent<SuggestEventPayload> {}

package/src/monaco/merge-editor-widget.ts

@@ -0,0 +1,159 @@
+import { URI, UriComponents } from '@opensumi/ide-core-common';
+import type { ICodeEditor } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import type { IEditor } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';
+import type { IEditorModel } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';
+
+export interface IMergeEditorEditor extends IEditor {
+  getOursEditor(): ICodeEditor;
+  getResultEditor(): ICodeEditor;
+  getTheirsEditor(): ICodeEditor;
+  open(openMergeEditorArgs: IOpenMergeEditorArgs): Promise<void>;
+}
+
+export interface IMergeEditorInputData {
+  uri: URI;
+  title?: string;
+  detail?: string; // 分支名
+  description?: string; // commit
+}
+
+export class MergeEditorInputData implements IMergeEditorInputData {
+  static from(data: string): MergeEditorInputData {
+    try {
+      const obj: MergeEditorInputData = JSON.parse(data);
+      return new MergeEditorInputData(obj.uri, obj.title, obj.detail, obj.description);
+    } catch (error) {
+      throw Error('invalid MergeEditorInputData parse');
+    }
+  }
+
+  private _textModel: IEditorModel;
+  public get textModel(): IEditorModel {
+    return this._textModel;
+  }
+
+  constructor(
+    readonly uri: URI,
+    readonly title?: string,
+    readonly detail?: string | undefined,
+    readonly description?: string | undefined,
+  ) {}
+
+  public getRaw(): IMergeEditorInputData {
+    return {
+      uri: this.uri,
+      title: this.title,
+      detail: this.detail,
+      description: this.description,
+    };
+  }
+
+  public toString(): string {
+    return JSON.stringify({
+      uri: this.uri.toString(),
+      title: this.title,
+      detail: this.detail,
+      description: this.description,
+    });
+  }
+
+  public setTextModel(model: IEditorModel): this {
+    this._textModel = model;
+    return this;
+  }
+}
+
+export interface IOpenMergeEditorArgs {
+  ancestor: {
+    uri: URI;
+    textModel: IEditorModel;
+  };
+  input1: MergeEditorInputData;
+  input2: MergeEditorInputData;
+  output: {
+    uri: URI;
+    textModel: IEditorModel;
+  };
+}
+
+interface IValidateOpenArgs {
+  ancestor: URI;
+  input1: MergeEditorInputData;
+  input2: MergeEditorInputData;
+  output: URI;
+}
+
+export namespace IRelaxedOpenMergeEditorArgs {
+  export const validate = (args: unknown): IValidateOpenArgs => {
+    if (!args || typeof args !== 'object') {
+      throw new TypeError('invalid argument');
+    }
+
+    const obj = args as IValidateOpenArgs;
+    const ancestor = toUri(obj.ancestor);
+    const output = toUri(obj.output);
+    const input1 = toInputData({
+      ...obj.input1,
+      title: obj.input1.title ?? 'Current',
+    });
+    const input2 = toInputData({
+      ...obj.input2,
+      title: obj.input2.title ?? 'Incoming',
+    });
+    return { ancestor, input1, input2, output };
+  };
+
+  export const toString = (args: IValidateOpenArgs): string => {
+    const { ancestor, input1, input2, output } = args;
+
+    return JSON.stringify({
+      ancestor: ancestor.toString(),
+      input1: input1.toString(),
+      input2: input2.toString(),
+      output: output.toString(),
+    });
+  };
+
+  const toInputData = (args: unknown): MergeEditorInputData => {
+    if (typeof args === 'string') {
+      return new MergeEditorInputData(URI.parse(args));
+    }
+    if (!args || typeof args !== 'object') {
+      throw new TypeError('invalid argument');
+    }
+
+    if (isUriComponents(args)) {
+      return new MergeEditorInputData(URI.from(args));
+    }
+
+    const obj = args as MergeEditorInputData;
+    const uri = toUri(obj.uri);
+    const title = obj.title;
+    const detail = obj.detail;
+    const description = obj.description;
+    return new MergeEditorInputData(uri, title, detail, description);
+  };
+
+  const toUri = (args: unknown): URI => {
+    if (typeof args === 'string') {
+      return URI.parse(args);
+    } else if (args && typeof args === 'object') {
+      return URI.from(args as UriComponents);
+    }
+    throw new TypeError('invalid argument');
+  };
+
+  const isUriComponents = (args: unknown): args is UriComponents => {
+    if (!args || typeof args !== 'object') {
+      return false;
+    }
+    const obj = args as UriComponents;
+    return (
+      typeof obj.scheme === 'string' &&
+      typeof obj.authority === 'string' &&
+      typeof obj.path === 'string' &&
+      typeof obj.query === 'string' &&
+      typeof obj.fragment === 'string'
+    );
+  };
+}

package/src/opener/command-opener.ts

@@ -0,0 +1,42 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, Schemes, CommandService } from '@opensumi/ide-core-common';
+
+import { IOpener } from '.';
+
+@Injectable()
+export class CommandOpener implements IOpener {
+  @Autowired(CommandService)
+  private readonly commandService: CommandService;
+
+  handleScheme(scheme: string) {
+    return scheme === Schemes.command;
+  }
+
+  static parseURI(uri: URI) {
+    // execute as command
+    let args: any = [];
+    try {
+      args = JSON.parse(decodeURIComponent(uri.query));
+    } catch (e) {
+      // ignore and retry
+      try {
+        args = JSON.parse(uri.query);
+      } catch (e) {
+        // ignore error
+      }
+    }
+    if (!Array.isArray(args)) {
+      args = [args];
+    }
+    return {
+      id: uri.path.toString(),
+      args,
+    };
+  }
+
+  async open(uri: URI) {
+    const { id, args } = CommandOpener.parseURI(uri);
+    await this.commandService.executeCommand(id, ...args);
+    return true;
+  }
+}

package/src/opener/default-opener.ts

@@ -0,0 +1,31 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, Schemes } from '@opensumi/ide-core-common';
+
+import { AppConfig } from '../react-providers/config-provider';
+import { IWindowService } from '../window';
+
+import { IOpener } from '.';
+
+@Injectable()
+export class DefaultOpener implements IOpener {
+  @Autowired(AppConfig)
+  private readonly appConfig: AppConfig;
+
+  @Autowired(IWindowService)
+  private readonly windowService: IWindowService;
+
+  handleScheme(scheme: string) {
+    return true;
+  }
+
+  async open(uri: URI) {
+    if (this.appConfig.isElectronRenderer || [Schemes.http, Schemes.https].includes(uri.scheme)) {
+      this.windowService.openNewWindow(uri.toString(true), {
+        external: true,
+      });
+    } else {
+      window.location.href = uri.toString(true);
+    }
+    return true;
+  }
+}