@opensumi/ide-core-browser 2.21.13-rc-1673328992.0 → 2.21.13

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

@@ -1,207 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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;
-  }
-}