@opensumi/ide-editor 2.21.13 → 2.22.0

package/src/browser/types.ts

@@ -0,0 +1,467 @@
+import {
+  MaybePromise,
+  IDisposable,
+  BasicEvent,
+  IRange,
+  MaybeNull,
+  ISelection,
+  URI,
+  Event,
+} from '@opensumi/ide-core-browser';
+import { IContextMenu } from '@opensumi/ide-core-browser/lib/menu/next';
+import { IThemeColor } from '@opensumi/ide-core-common';
+import { editor } from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import {
+  IResource,
+  ResourceService,
+  IEditorGroup,
+  IDecorationRenderOptions,
+  ITextEditorDecorationType,
+  TrackedRangeStickiness,
+  OverviewRulerLane,
+  IEditorOpenType,
+  IEditor,
+  DragOverPosition,
+} from '../common';
+
+import { IEditorDocumentModelContentRegistry } from './doc-model/types';
+
+export * from '../common';
+
+export type ReactEditorComponent<MetaData = any> = React.ComponentType<{ resource: IResource<MetaData> }>;
+
+export interface IEditorComponent<MetaData = any> {
+  // 唯一id
+  uid: string;
+
+  // component 对象
+  component: ReactEditorComponent<MetaData>;
+
+  // 要被handle的scheme
+  // @deprecated
+  scheme?: string;
+
+  // 渲染模式 默认为 ONE_PER_GROUP
+  renderMode?: EditorComponentRenderMode;
+}
+
+export type EditorSide = 'bottom';
+
+export interface IEditorSideWidget<MetaData = any> {
+  /**
+   * id, 需要唯一，会作为react组件的key
+   */
+  id: string;
+
+  /**
+   * TODO: 当前仅支持bottom
+   */
+  side?: EditorSide;
+
+  /**
+   * 组件元素
+   */
+  component: ReactEditorComponent<MetaData>;
+
+  /**
+   * 排序因子, 默认10
+   */
+  weight?: number;
+
+  /**
+   * 是否要在某个resource显示
+   */
+  displaysOnResource: (resource: IResource<any>) => boolean;
+
+  /**
+   * editorSide view 组件传入的props
+   */
+  initialProps?: unknown;
+}
+
+export enum EditorComponentRenderMode {
+  ONE_PER_RESOURCE = 1, // 每个resource渲染一个新的
+  ONE_PER_GROUP = 2, // 每个Group最多存在一个新的
+  ONE_PER_WORKBENCH = 3, // 整个IDE只有一个, 视图会被重用
+}
+
+/**
+ * 注册编辑器组件 Resolver 时触发
+ */
+export class RegisterEditorComponentResolverEvent extends BasicEvent<string> {}
+
+/**
+ * 注册编辑器组件时触发
+ */
+export class RegisterEditorComponentEvent extends BasicEvent<string> {}
+
+export abstract class EditorComponentRegistry {
+  abstract registerEditorComponent<T>(component: IEditorComponent<T>, initialProps?: any): IDisposable;
+
+  // 等同于 handlesScheme => 10
+  abstract registerEditorComponentResolver<T>(scheme: string, resolver: IEditorComponentResolver<T>): IDisposable;
+
+  // handlesScheme 返回权重， 小于 0 表示不处理
+  abstract registerEditorComponentResolver<T>(
+    // eslint-disable-next-line @typescript-eslint/unified-signatures
+    handlesScheme: (scheme: string) => number,
+    resolver: IEditorComponentResolver<T>,
+  ): IDisposable;
+
+  abstract resolveEditorComponent(resource: IResource): Promise<IEditorOpenType[]>;
+
+  abstract getEditorComponent(id: string): IEditorComponent | null;
+
+  abstract getEditorInitialProps(id: string): any;
+
+  abstract clearPerWorkbenchComponentCache(componentId: string): void;
+
+  /**
+   * 注册一个编辑器的边缘组件（目前只开放了bottom)
+   * @param widget
+   */
+  abstract registerEditorSideWidget(widget: IEditorSideWidget): IDisposable;
+
+  abstract getSideWidgets(side: EditorSide, resource: IResource): IEditorSideWidget<any>[];
+}
+
+/**
+ * 打开资源的处理委派函数
+ * @param resource 要打开的资源
+ * @param results 在执行此责任委派函数前，已经支持的打开方式
+ * @param resolve 调用这个函数，传入结果可结束责任链直接返回支持的打开方式
+ */
+export type IEditorComponentResolver<MetaData = any> = (
+  resource: IResource<MetaData>,
+  results: IEditorOpenType[],
+  resolve: (results: IEditorOpenType[]) => void,
+) => MaybePromise<void>;
+
+export const BrowserEditorContribution = Symbol('BrowserEditorContribution');
+
+export interface BrowserEditorContribution {
+  /**
+   * 用来在合适的时机向 `ResourceService` 注册可以在编辑器内打开的资源。
+   *
+   * 为了让一个 uri 能够在编辑器中被打开，首先需要向 `ResourceService` 注册一个用于解析 uri 至一个编辑器资源（`IResource`) 的 `IResourceProvider`。
+   * 它的主要职责是在这个 uri 在编辑器标签 Tab 上显示时提供它的名称、图标、是否被编辑等状态，以及相应这个 tab 被关闭时的回调等等。
+   *
+   * @param resourceService
+   */
+  registerResource?(resourceService: ResourceService): void;
+
+  /**
+   * 用来在合适的时机向 `EditorComponentRegistry` 注册编辑器组件、打开方式等功能。
+   *
+   * 一个 uri 对应的编辑器资源 (`IResource`) 需要能够在编辑器中展示，还需要为它注册对应的一个或者多个打开方式，以及对应打开方式使用的 React 组件。
+   * @param editorComponentRegistry
+   */
+  registerEditorComponent?(editorComponentRegistry: EditorComponentRegistry): void;
+
+  registerEditorDocumentModelContentProvider?(registry: IEditorDocumentModelContentRegistry): void;
+
+  /**
+   * @deprecated
+   * @param editorActionRegistry
+   */
+  registerEditorActions?(editorActionRegistry: IEditorActionRegistry): void;
+
+  /**
+   * 当进入 IDE 时，编辑器会尝试恢复上一次打开的编辑器组和组内打开的文件
+   * 完成后会执行 onDidRestoreState 这个 hook
+   */
+  onDidRestoreState?(): void;
+
+  registerEditorFeature?(registry: IEditorFeatureRegistry);
+}
+
+export interface IGridResizeEventPayload {
+  gridId: string;
+}
+
+export class GridResizeEvent extends BasicEvent<IGridResizeEventPayload> {}
+
+export class EditorGroupOpenEvent extends BasicEvent<{ group: IEditorGroup; resource: IResource }> {}
+export class EditorGroupCloseEvent extends BasicEvent<{ group: IEditorGroup; resource: IResource }> {}
+export class EditorGroupDisposeEvent extends BasicEvent<{ group: IEditorGroup }> {}
+
+export class EditorGroupChangeEvent extends BasicEvent<IEditorGroupChangePayload> {}
+
+export class EditorActiveResourceStateChangedEvent extends BasicEvent<{
+  resource: MaybeNull<IResource>;
+  openType: MaybeNull<IEditorOpenType>;
+  // 如果是编辑器，当前编辑器的 uri
+  editorUri?: MaybeNull<URI>;
+}> {}
+
+export interface IEditorGroupChangePayload {
+  group: IEditorGroup;
+
+  oldResource: MaybeNull<IResource>;
+
+  newResource: MaybeNull<IResource>;
+
+  oldOpenType: MaybeNull<IEditorOpenType>;
+
+  newOpenType: MaybeNull<IEditorOpenType>;
+}
+
+export class EditorGroupFileDropEvent extends BasicEvent<IEditorGroupFileDropPayload> {}
+
+export interface IEditorGroupFileDropPayload {
+  files: FileList;
+
+  group: IEditorGroup;
+
+  /**
+   * 如果目标在tab上, drop目标tab的位置
+   * -1表示在tab的空位置
+   */
+  tabIndex?: number;
+
+  /**
+   * 如果扔在编辑器主体，扔的位置
+   */
+  position?: DragOverPosition;
+}
+
+export interface IEditorDecorationCollectionService {
+  createTextEditorDecorationType(options: IDecorationRenderOptions, key?: string): IBrowserTextEditorDecorationType;
+  getTextEditorDecorationType(key): IBrowserTextEditorDecorationType | undefined;
+  registerDecorationProvider(provider: IEditorDecorationProvider): IDisposable;
+  getDecorationFromProvider(uri: URI, key?: string): Promise<{ [key: string]: editor.IModelDeltaDecoration[] }>;
+}
+
+export interface IBrowserTextEditorDecorationType extends ITextEditorDecorationType {
+  property: IDynamicModelDecorationProperty;
+}
+
+export interface IDynamicModelDecorationProperty extends IDisposable {
+  default: IThemedCssStyle;
+
+  light: IThemedCssStyle | null;
+
+  dark: IThemedCssStyle | null;
+
+  rangeBehavior?: TrackedRangeStickiness;
+
+  overviewRulerLane?: OverviewRulerLane;
+
+  isWholeLine: boolean;
+}
+
+export interface IThemedCssStyle extends IDisposable {
+  glyphMarginClassName?: string;
+  className?: string;
+  inlineClassName?: string;
+  afterContentClassName?: string;
+  beforeContentClassName?: string;
+  overviewRulerColor?: string | IThemeColor;
+}
+
+export const IEditorDecorationCollectionService = Symbol('IEditorDecorationCollectionService');
+
+export class EditorSelectionChangeEvent extends BasicEvent<IEditorSelectionChangeEventPayload> {}
+
+export interface IEditorSelectionChangeEventPayload {
+  group: IEditorGroup;
+
+  resource: IResource;
+
+  selections: ISelection[];
+
+  source: string | undefined;
+
+  editorUri: URI;
+
+  side?: 'original' | 'modified';
+}
+
+export class EditorVisibleChangeEvent extends BasicEvent<IEditorVisibleChangeEventPayload> {}
+
+export interface IEditorVisibleChangeEventPayload {
+  group: IEditorGroup;
+
+  resource: IResource;
+
+  visibleRanges: IRange[];
+
+  editorUri: URI;
+}
+
+export class EditorConfigurationChangedEvent extends BasicEvent<IEditorConfigurationChangedEventPayload> {}
+
+export interface IEditorConfigurationChangedEventPayload {
+  group: IEditorGroup;
+
+  resource: IResource;
+
+  editorUri: URI;
+}
+
+export class EditorGroupIndexChangedEvent extends BasicEvent<IEditorGroupIndexChangeEventPayload> {}
+
+export interface IEditorGroupIndexChangeEventPayload {
+  group: IEditorGroup;
+
+  index: number;
+}
+
+export class EditorGroupsResetSizeEvent extends BasicEvent<void> {}
+
+export class RegisterEditorSideComponentEvent extends BasicEvent<void> {}
+
+export interface IEditorDecorationProvider {
+  // 装饰要命中的uri scheme, 不传会命中所有scheme
+  schemes?: string[];
+
+  // 同一个key的decoration会覆盖
+  key: string;
+
+  // 提供decoration
+  provideEditorDecoration(uri: URI): MaybePromise<editor.IModelDeltaDecoration[] | undefined>;
+
+  // decorationChange事件
+  onDidDecorationChange: Event<URI>;
+}
+
+export class EditorDecorationProviderRegistrationEvent extends BasicEvent<IEditorDecorationProvider> {}
+
+export class EditorDecorationChangeEvent extends BasicEvent<{ uri: URI; key: string }> {}
+
+export class EditorDecorationTypeRemovedEvent extends BasicEvent<string> {}
+
+export interface IEditorActionRegistry {
+  /**
+   * 请不要再使用,暂时除了tip相关和isVisible仍然兼容
+   * @deprecated
+   * @param
+   */
+  registerEditorAction(action: IEditorActionItem): IDisposable;
+
+  getMenu(group: IEditorGroup): IContextMenu;
+}
+
+export interface IEditorActionItem {
+  title: string;
+  iconClass: string;
+  tip?: string;
+  tipWhen?: string;
+  tipClass?: string;
+  /**
+   * @deprecated 现在无效
+   */
+  isVisible?: (resource: MaybeNull<IResource>, editorGroup: IEditorGroup) => boolean;
+  /**
+   * @deprecated 现在会自动转为临时command
+   */
+  onClick: (resource: MaybeNull<IResource>, editorGroup: IEditorGroup) => void;
+  when?: string; // 使用contextkey
+}
+
+export interface IVisibleAction {
+  item: IEditorActionItem;
+  tipVisible: boolean;
+  closeTip(): void;
+}
+
+export const IEditorActionRegistry = Symbol('IEditorActionRegistry');
+
+export interface ICompareService {
+  /**
+   * 在编辑器中compare两个文件
+   */
+  compare(original: URI, modified: URI, name: string): Promise<CompareResult>;
+}
+
+export const ICompareService = Symbol('ICompareService');
+
+export enum CompareResult {
+  revert = 'revert', // original -> modified
+  accept = 'accept', // modified -> original
+  cancel = 'cancel',
+}
+
+export interface IBreadCrumbService {
+  registerBreadCrumbProvider(provider: IBreadCrumbProvider): IDisposable;
+
+  getBreadCrumbs(uri: URI, editor?: MaybeNull<IEditor>): IBreadCrumbPart[] | undefined;
+
+  disposeCrumb(uri: URI): void;
+
+  onDidUpdateBreadCrumbResults: Event<{ editor: MaybeNull<IEditor>; uri: URI }>;
+}
+
+export const IBreadCrumbService = Symbol('IBreadScrumbService');
+
+export interface IBreadCrumbProvider {
+  handlesUri(URI: URI): boolean;
+
+  provideBreadCrumbForUri(uri: URI, editor?: MaybeNull<IEditor>): IBreadCrumbPart[];
+
+  onDidUpdateBreadCrumb: Event<URI>;
+}
+
+export interface IBreadCrumbPart {
+  name: string;
+
+  icon?: string;
+
+  getSiblings?(): MaybePromise<{ parts: IBreadCrumbPart[]; currentIndex: number }>;
+
+  // getChildren和onClick只能存在一个，如果同时存在,getChildren生效
+  getChildren?(): MaybePromise<IBreadCrumbPart[]>;
+
+  onClick?(): void;
+}
+
+export const IEditorFeatureRegistry = Symbol('IEditorFeatureRegistry');
+
+export interface IEditorFeatureRegistry {
+  /**
+   * 注册一个用来加强编辑器能力的Contribution
+   * @param contribution
+   */
+  registerEditorFeatureContribution(contribution: IEditorFeatureContribution): IDisposable;
+
+  /**
+   * 运行 contrbute
+   */
+  runContributions(editor: IEditor): void;
+
+  /**
+   * 运行 provideEditorOptionsForUri
+   */
+  runProvideEditorOptionsForUri(uri: URI): MaybePromise<editor.IEditorOptions>;
+}
+
+export interface IConvertedMonacoOptions {
+  editorOptions: Partial<editor.IEditorOptions>;
+  modelOptions: Partial<editor.ITextModelUpdateOptions>;
+  diffOptions: Partial<editor.IDiffEditorOptions>;
+}
+
+export interface IEditorFeatureContribution {
+  /**
+   * 当一个编辑器被创建时，会调用这个API，返回的Disposable会在编辑器被销毁时执行
+   * @param editor
+   */
+  contribute(editor: IEditor): IDisposable;
+
+  /**
+   * 用来对 uri 进行 options 的修改
+   * @param editor
+   */
+  provideEditorOptionsForUri?(uri: URI): MaybePromise<Partial<editor.IEditorOptions>>;
+}
+
+export class ResourceOpenTypeChangedEvent extends BasicEvent<URI> {}
+
+export class EditorComponentDisposeEvent extends BasicEvent<IEditorComponent> {}
+
+export class CodeEditorDidVisibleEvent extends BasicEvent<{
+  type: 'code' | 'diff';
+  groupName: string;
+  editorId: string;
+}> {}

package/src/browser/untitled-resource.ts

@@ -0,0 +1,223 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  URI,
+  Emitter,
+  Event,
+  Schemes,
+  WithEventBus,
+  IEditorDocumentChange,
+  IEditorDocumentModelSaveResult,
+  AppConfig,
+  CommandService,
+  OperatingSystem,
+  IApplicationService,
+  PreferenceService,
+  getLanguageIdFromMonaco,
+  localize,
+  formatLocalize,
+  MessageType,
+  path,
+  isWindows,
+  SaveTaskResponseState,
+} from '@opensumi/ide-core-browser';
+import { EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+import { IDialogService } from '@opensumi/ide-overlay';
+
+import { AskSaveResult, IResource, IResourceProvider, WorkbenchEditorService } from '../common';
+
+import { IEditorDocumentModelService, IEditorDocumentModelContentProvider } from './doc-model/types';
+
+@Injectable()
+export class UntitledDocumentIdCounter {
+  private _id = 1;
+
+  get id() {
+    return this._id++;
+  }
+}
+
+@Injectable()
+export class UntitledSchemeDocumentProvider implements IEditorDocumentModelContentProvider {
+  @Autowired(IEditorDocumentModelService)
+  editorDocumentModelService: IEditorDocumentModelService;
+
+  @Autowired(WorkbenchEditorService)
+  workbenchEditorService: WorkbenchEditorService;
+
+  @Autowired(CommandService)
+  private readonly commandService: CommandService;
+
+  @Autowired(AppConfig)
+  protected readonly appConfig: AppConfig;
+
+  @Autowired(IApplicationService)
+  protected readonly applicationService: IApplicationService;
+
+  private _onDidChangeContent: Emitter<URI> = new Emitter();
+
+  public onDidChangeContent: Event<URI> = this._onDidChangeContent.event;
+
+  @Autowired(PreferenceService)
+  protected readonly preferenceService: PreferenceService;
+
+  handlesScheme(scheme: string): boolean {
+    return scheme === Schemes.untitled;
+  }
+
+  async provideEncoding(uri: URI) {
+    const encoding = this.preferenceService.get<string>(
+      'files.encoding',
+      undefined,
+      uri.toString(),
+      getLanguageIdFromMonaco(uri)!,
+    );
+    return encoding || 'utf8';
+  }
+
+  async provideEOL(uri: URI) {
+    const backendOS = await this.applicationService.getBackendOS();
+    const eol = this.preferenceService.get<EOL | 'auto'>(
+      'files.eol',
+      'auto',
+      uri.toString(),
+      getLanguageIdFromMonaco(uri)!,
+    )!;
+
+    if (eol !== 'auto') {
+      return eol;
+    }
+    return backendOS === OperatingSystem.Windows ? EOL.CRLF : EOL.LF;
+  }
+
+  async provideEditorDocumentModelContent(uri: URI, encoding?: string | undefined): Promise<string> {
+    return '';
+  }
+
+  isReadonly(uri: URI): boolean {
+    return false;
+  }
+
+  isAlwaysDirty(uri: URI): boolean {
+    // untitled 文件允许新建后就可以保存
+    return true;
+  }
+
+  disposeEvenDirty(uri: URI): boolean {
+    // untitled 即便是 dirty 状态下，在关闭后也要被 dispose
+    return true;
+  }
+
+  closeAutoSave(uri: URI): boolean {
+    return true;
+  }
+
+  async saveDocumentModel(
+    uri: URI,
+    content: string,
+    baseContent: string,
+    changes: IEditorDocumentChange[],
+    encoding: string,
+    ignoreDiff = false,
+  ): Promise<IEditorDocumentModelSaveResult> {
+    const { name } = uri.getParsedQuery();
+    const defaultPath = uri.path.toString() !== '/' ? path.dirname(uri.path.toString()) : this.appConfig.workspaceDir;
+    const saveUri = await this.commandService.tryExecuteCommand<URI>('file.save', {
+      showNameInput: true,
+      defaultFileName: name || uri.displayName,
+      defaultUri: URI.file(isWindows ? defaultPath.replaceAll('\\', '/') : defaultPath),
+    });
+    if (saveUri) {
+      await this.editorDocumentModelService.saveEditorDocumentModel(
+        saveUri,
+        content,
+        baseContent,
+        changes,
+        encoding,
+        ignoreDiff,
+      );
+      // TODO: 不依赖 workspaceEditor，先关闭再打开，等 fileSystemProvider 迁移到前端再做改造
+      await this.workbenchEditorService.open(saveUri, {
+        preview: false,
+        focus: true,
+        replace: true,
+        forceClose: true,
+      });
+    }
+    return {
+      state: SaveTaskResponseState.SUCCESS,
+    };
+  }
+  onDidDisposeModel() {}
+}
+
+@Injectable()
+export class UntitledSchemeResourceProvider extends WithEventBus implements IResourceProvider {
+  readonly scheme: string = Schemes.untitled;
+
+  @Autowired(IDialogService)
+  protected dialogService: IDialogService;
+
+  @Autowired(IEditorDocumentModelService)
+  protected documentModelService: IEditorDocumentModelService;
+
+  provideResource(uri: URI) {
+    const { name } = uri.getParsedQuery();
+    return {
+      name: name || uri.displayName,
+      uri,
+      icon: '',
+      metadata: null,
+    };
+  }
+
+  async shouldCloseResourceWithoutConfirm(resource: IResource) {
+    const documentModelRef = this.documentModelService.getModelReference(resource.uri, 'close-resource-check');
+    if (documentModelRef && documentModelRef.instance.dirty) {
+      return true;
+    }
+    return false;
+  }
+
+  async close(resource: IResource, saveAction?: AskSaveResult) {
+    const documentModelRef = this.documentModelService.getModelReference(resource.uri, 'close-resource-check');
+    if (!documentModelRef) {
+      return false;
+    }
+    if (saveAction === AskSaveResult.SAVE) {
+      const res = await documentModelRef.instance.save();
+      documentModelRef.dispose();
+      return res;
+    } else if (saveAction === AskSaveResult.REVERT) {
+      await documentModelRef.instance.revert();
+      documentModelRef.dispose();
+      return true;
+    } else if (!saveAction || saveAction === AskSaveResult.CANCEL) {
+      documentModelRef.dispose();
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  async shouldCloseResource(resource: IResource) {
+    const documentModelRef = this.documentModelService.getModelReference(resource.uri, 'close-resource-check');
+    if (!documentModelRef || !documentModelRef.instance.dirty) {
+      if (documentModelRef) {
+        documentModelRef.dispose();
+      }
+      return true;
+    }
+    // 询问用户是否保存
+    const buttons = {
+      [localize('file.prompt.dontSave', '不保存')]: AskSaveResult.REVERT,
+      [localize('file.prompt.save', '保存')]: AskSaveResult.SAVE,
+      [localize('file.prompt.cancel', '取消')]: AskSaveResult.CANCEL,
+    };
+    const selection = await this.dialogService.open(
+      formatLocalize('saveChangesMessage', resource.name),
+      MessageType.Info,
+      Object.keys(buttons),
+    );
+    return await this.close(resource, buttons[selection!]);
+  }
+}