@opensumi/ide-workspace-edit 2.21.13 → 2.22.0

package/src/browser/workspace-edit.service.ts

@@ -0,0 +1,354 @@
+import { runInAction } from 'mobx';
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, IEventBus, isWindows, isUndefined } from '@opensumi/ide-core-browser';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { IEditorDocumentModelService, IResource, isDiffResource } from '@opensumi/ide-editor/lib/browser';
+import { EditorGroup } from '@opensumi/ide-editor/lib/browser/workbench-editor.service';
+import { FileSystemError } from '@opensumi/ide-file-service/lib/common';
+import { EndOfLineSequence, EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+import { Range } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import {
+  IResourceTextEdit,
+  IWorkspaceEditService,
+  IWorkspaceEdit,
+  IResourceFileEdit,
+  WorkspaceEditDidRenameFileEvent,
+  WorkspaceEditDidDeleteFileEvent,
+  IWorkspaceFileService,
+} from '../common';
+
+type WorkspaceEdit = ResourceTextEditTask | ResourceFileEdit;
+
+@Injectable()
+export class WorkspaceEditServiceImpl implements IWorkspaceEditService {
+  private editStack: BulkEdit[] = [];
+
+  @Autowired(IEditorDocumentModelService)
+  documentModelService: IEditorDocumentModelService;
+
+  @Autowired(IWorkspaceFileService)
+  workspaceFileService: IWorkspaceFileService;
+
+  @Autowired()
+  editorService: WorkbenchEditorService;
+
+  @Autowired(IEventBus)
+  eventBus: IEventBus;
+
+  async apply(edit: IWorkspaceEdit): Promise<void> {
+    const bulkEdit = new BulkEdit();
+    edit.edits.forEach((edit) => {
+      bulkEdit.add(edit);
+    });
+    await bulkEdit.apply(this.documentModelService, this.editorService, this.workspaceFileService, this.eventBus);
+    this.editStack.push(bulkEdit);
+  }
+
+  revertTopFileEdit(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class BulkEdit {
+  private edits: WorkspaceEdit[] = [];
+
+  async apply(
+    documentModelService: IEditorDocumentModelService,
+    editorService: WorkbenchEditorService,
+    workspaceFS: IWorkspaceFileService,
+    eventBus: IEventBus,
+  ) {
+    for (const edit of this.edits) {
+      if (edit instanceof ResourceFileEdit) {
+        await edit.apply(documentModelService, editorService, workspaceFS, eventBus);
+      } else {
+        await edit.apply(documentModelService, editorService);
+      }
+    }
+  }
+
+  add(edit: IResourceTextEdit | IResourceFileEdit) {
+    if (isResourceFileEdit(edit)) {
+      this.edits.push(new ResourceFileEdit(edit));
+    } else {
+      const last = this.edits[this.edits.length - 1];
+      const textEdit = edit as IResourceTextEdit;
+      if (last && !isResourceFileEdit(last)) {
+        // 合并连续同目标的edits
+        if (last.resource.toString() === textEdit.resource.toString()) {
+          let shouldMerge = false;
+          if (last.versionId) {
+            if (textEdit.versionId) {
+              shouldMerge = textEdit.versionId === last.versionId;
+            } else {
+              shouldMerge = true;
+            }
+          } else {
+            if (!textEdit.versionId) {
+              shouldMerge = true;
+            }
+          }
+          if (shouldMerge) {
+            last.addEdit(edit as IResourceTextEdit);
+            return;
+          }
+        }
+      }
+      this.edits.push(new ResourceTextEditTask(edit as IResourceTextEdit));
+    }
+  }
+
+  revert(onlyFileEdits: true) {}
+}
+
+export class ResourceTextEditTask {
+  public edits: IResourceTextEdit[];
+  public resource: URI;
+  public versionId: number | undefined;
+  public options: {
+    openDirtyInEditor?: boolean;
+    dirtyIfInEditor?: boolean;
+  } = {};
+
+  constructor(edit: IResourceTextEdit) {
+    this.resource = edit.resource;
+    this.versionId = edit.versionId;
+    this.options = edit.options || {};
+    this.edits = [edit];
+  }
+
+  addEdit(edit: IResourceTextEdit) {
+    this.edits.push(edit);
+  }
+
+  async apply(documentModelService: IEditorDocumentModelService, editorService: WorkbenchEditorService) {
+    const docRef = await documentModelService.createModelReference(this.resource, 'bulk-edit');
+    const documentModel = docRef.instance;
+    const monacoModel = documentModel.getMonacoModel();
+    if (this.versionId) {
+      if (monacoModel.getVersionId() !== this.versionId) {
+        throw new Error('文档版本不一致，无法执行变更');
+      }
+    }
+    const edits: monaco.editor.IIdentifiedSingleEditOperation[] = [];
+    let newEOL: EndOfLineSequence | undefined;
+    for (const edit of this.edits) {
+      if (edit.textEdit.eol && !isUndefined(edit.textEdit.eol)) {
+        newEOL = edit.textEdit.eol;
+      }
+      edits.push({
+        forceMoveMarkers: false,
+        range: Range.lift(edit.textEdit.range),
+        text: edit.textEdit.text,
+      });
+    }
+
+    if (edits.length > 0) {
+      monacoModel.pushStackElement();
+      monacoModel.pushEditOperations(null, edits, () => null);
+      monacoModel.pushStackElement();
+    }
+
+    if (newEOL && !isUndefined(newEOL)) {
+      monacoModel.pushStackElement();
+      documentModel.eol = newEOL === EndOfLineSequence.CRLF ? EOL.CRLF : EOL.LF;
+      monacoModel.pushStackElement();
+    }
+    const shouldSave = await this.editorOperation(editorService);
+    if (shouldSave) {
+      documentModel.save();
+    }
+    docRef.dispose();
+  }
+
+  // 返回是否保存
+  private async editorOperation(editorService: WorkbenchEditorService): Promise<boolean> {
+    if (this.options.openDirtyInEditor) {
+      for (const group of editorService.editorGroups) {
+        if (group.resources.findIndex((r) => isDocumentUriInResource(r, this.resource)) !== -1) {
+          return false;
+        }
+      }
+      editorService.open(this.resource, { backend: true });
+      return false;
+    } else if (this.options.dirtyIfInEditor) {
+      for (const group of editorService.editorGroups) {
+        if (group.resources.findIndex((r) => isDocumentUriInResource(r, this.resource)) !== -1) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  async revert(): Promise<void> {}
+}
+
+export class ResourceFileEdit implements IResourceFileEdit {
+  oldResource?: URI;
+  newResource?: URI;
+  options: {
+    overwrite?: boolean | undefined;
+    ignoreIfNotExists?: boolean | undefined;
+    recursive?: boolean | undefined;
+    showInEditor?: boolean;
+    isDirectory?: boolean;
+    copy?: boolean;
+    ignoreIfExists?: boolean | undefined;
+    content?: string;
+  } = {};
+
+  constructor(edit: IResourceFileEdit) {
+    this.oldResource = edit.oldResource;
+    this.newResource = edit.newResource;
+    this.options = edit.options;
+  }
+
+  async notifyEditor(editorService: WorkbenchEditorService, documentModelService: IEditorDocumentModelService) {
+    if (this.oldResource && this.newResource) {
+      const promises: Promise<any>[] = [];
+      const urisToDealWith: Set<string> = new Set();
+      editorService.editorGroups.forEach((g) => {
+        g.resources.forEach((r) => {
+          if (this.oldResource!.isEqualOrParent(r.uri)) {
+            urisToDealWith.add(r.uri.toString());
+          }
+        });
+      });
+      urisToDealWith.forEach((uriString) => {
+        const oldResource = new URI(uriString);
+        const subPath = uriString.substr(this.oldResource!.toString().length);
+        const newResource = new URI(this.newResource!.toString()! + subPath);
+        promises.push(this.notifyOnResource(oldResource, newResource, editorService, documentModelService));
+      });
+      return Promise.all(promises);
+    }
+  }
+
+  async notifyOnResource(
+    oldResource: URI,
+    newResource: URI,
+    editorService: WorkbenchEditorService,
+    documentModelService: IEditorDocumentModelService,
+  ) {
+    const docRef = documentModelService.getModelReference(oldResource, 'bulk-file-move');
+    let dirtyContent: string | undefined;
+    let dirtyEOL: EOL | undefined;
+    if (docRef && docRef.instance.dirty) {
+      dirtyContent = docRef.instance.getText();
+      dirtyEOL = docRef.instance.eol;
+      await docRef.instance.revert(true);
+    }
+    if (docRef) {
+      docRef.dispose();
+    }
+    // 如果之前的文件在编辑器中被打开，重新打开文件
+    await Promise.all([
+      editorService.editorGroups.map(async (g) => {
+        const index = g.resources.findIndex((r) => r.uri.isEqual(oldResource));
+        if (index !== -1) {
+          await runInAction(async () => {
+            await g.open(newResource, {
+              index,
+              backend: !(g.currentResource && g.currentResource.uri.isEqual(oldResource)),
+              // 如果旧的是preview模式，应该保持，如果不是，应该不要关闭其他处于preview模式的资源tab
+              preview: (g as EditorGroup).previewURI ? (g as EditorGroup).previewURI!.isEqual(oldResource) : false,
+            });
+            await g.close(oldResource);
+          });
+        }
+      }),
+    ]);
+
+    if (dirtyContent) {
+      const newDocRef = await documentModelService.createModelReference(newResource, 'bulk-file-move');
+      newDocRef.instance.updateContent(dirtyContent, dirtyEOL);
+      newDocRef.dispose();
+    }
+  }
+
+  async apply(
+    documentModelService: IEditorDocumentModelService,
+    editorService: WorkbenchEditorService,
+    workspaceFS: IWorkspaceFileService,
+    eventBus: IEventBus,
+  ) {
+    const options = this.options || {};
+
+    if (this.newResource && this.oldResource) {
+      if (options.copy) {
+        await workspaceFS.copy([{ source: this.oldResource.codeUri, target: this.newResource.codeUri }], options);
+      } else {
+        // rename
+        await workspaceFS.move([{ source: this.oldResource.codeUri, target: this.newResource.codeUri }], options);
+
+        await this.notifyEditor(editorService, documentModelService);
+
+        // TODO: 文件夹rename应该带传染性, 但是遍历实现比较坑，先不实现
+        eventBus.fire(new WorkspaceEditDidRenameFileEvent({ oldUri: this.oldResource, newUri: this.newResource }));
+      }
+
+      if (options.showInEditor) {
+        editorService.open(this.newResource);
+      }
+    } else if (!this.newResource && this.oldResource) {
+      // 删除文件
+      try {
+        // electron windows下moveToTrash大量文件会导致IDE卡死，如果检测到这个情况就不使用moveToTrash
+        await workspaceFS.delete([this.oldResource], {
+          useTrash: !(isWindows && this.oldResource.path.name === 'node_modules'),
+        });
+        // 默认recursive
+        await editorService.close(this.oldResource, true);
+        eventBus.fire(new WorkspaceEditDidDeleteFileEvent({ oldUri: this.oldResource }));
+      } catch (err) {
+        if (FileSystemError.FileNotFound.is(err) && options.ignoreIfNotExists) {
+          // 不抛出错误
+        } else {
+          throw err;
+        }
+      }
+    } else if (this.newResource && !this.oldResource) {
+      // 创建文件
+      try {
+        if (options.isDirectory) {
+          await workspaceFS.createFolder(this.newResource);
+        } else {
+          await workspaceFS.create(this.newResource, options.content || '', { overwrite: options.overwrite });
+        }
+      } catch (err) {
+        if (FileSystemError.FileExists.is(err) && options.ignoreIfExists) {
+          // 不抛出错误
+        } else {
+          throw err;
+        }
+      }
+      if (!options.isDirectory && options.showInEditor) {
+        editorService.open(this.newResource);
+      }
+    }
+  }
+
+  async revert(): Promise<void> {}
+}
+
+export function isResourceFileEdit(thing: any): thing is ResourceFileEdit {
+  return !!(thing as ResourceFileEdit).newResource || !!(thing as ResourceFileEdit).oldResource;
+}
+
+/**
+ * 当前编辑器的文档是否在指定的编辑器 resource (tab) 中
+ * 此处需要额外判断一下 diffEditor 的情况
+ * @param resource
+ * @param uri
+ */
+function isDocumentUriInResource(resource: IResource<any>, uri: URI) {
+  if (isDiffResource(resource)) {
+    return resource.metadata?.modified.isEqual(uri) || resource.metadata?.original.isEqual(uri);
+  } else {
+    return resource.uri.isEqual(uri);
+  }
+}

package/src/browser/workspace-file.service.ts

@@ -0,0 +1,206 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { IProgressService } from '@opensumi/ide-core-browser/lib/progress';
+import {
+  URI,
+  Uri,
+  CancellationTokenSource,
+  CancellationToken,
+  Disposable,
+  IDisposable,
+  getDebugLogger,
+  AsyncEmitter,
+  Event,
+  FileStat,
+} from '@opensumi/ide-core-common';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+import {
+  FileOperation,
+  FILE_OPERATION_TIMEOUT,
+  IWorkspaceFileOperationParticipant,
+  IWorkspaceFileService,
+  SourceTargetPair,
+  WorkspaceFileEvent,
+} from '..';
+
+@Injectable()
+export class WorkspaceFileOperationParticipant extends Disposable {
+  @Autowired(IProgressService)
+  progressService: IProgressService;
+
+  participants: IWorkspaceFileOperationParticipant[] = [];
+
+  registerParticipant(participant: IWorkspaceFileOperationParticipant): IDisposable {
+    this.participants.push(participant);
+    return {
+      dispose: () => {
+        const index = this.participants.findIndex((item) => item === participant);
+        this.participants.splice(index, 1);
+      },
+    };
+  }
+
+  async participate(files: { source?: Uri; target: Uri }[], operation: FileOperation): Promise<void> {
+    const cts = new CancellationTokenSource();
+    for (const participant of this.participants) {
+      if (cts.token.isCancellationRequested) {
+        break;
+      }
+
+      try {
+        await participant.participate(files, operation, undefined, FILE_OPERATION_TIMEOUT, cts.token);
+      } catch (err) {
+        getDebugLogger().error(err);
+      }
+    }
+  }
+
+  dispose() {
+    this.participants.splice(0, this.participants.length);
+  }
+}
+
+@Injectable()
+export class WorkspaceFileService implements IWorkspaceFileService {
+  @Autowired(IFileServiceClient)
+  private readonly fileService: IFileServiceClient;
+
+  @Autowired(WorkspaceFileOperationParticipant)
+  private readonly fileOperationParticipants: WorkspaceFileOperationParticipant;
+
+  private correlationIds = 0;
+
+  private readonly _onWillRunWorkspaceFileOperation = new AsyncEmitter<WorkspaceFileEvent>();
+  public readonly onWillRunWorkspaceFileOperation: Event<WorkspaceFileEvent> =
+    this._onWillRunWorkspaceFileOperation.event;
+
+  private readonly _onDidFailWorkspaceFileOperation = new AsyncEmitter<WorkspaceFileEvent>();
+  public readonly onDidFailWorkspaceFileOperation: Event<WorkspaceFileEvent> =
+    this._onDidFailWorkspaceFileOperation.event;
+
+  private readonly _onDidRunWorkspaceFileOperation = new AsyncEmitter<WorkspaceFileEvent>();
+  public readonly onDidRunWorkspaceFileOperation: Event<WorkspaceFileEvent> =
+    this._onDidRunWorkspaceFileOperation.event;
+
+  public create(resource: URI, contents?: string, options?: { overwrite?: boolean }) {
+    return this.doCreate(resource, true, contents, options);
+  }
+
+  public createFolder(resource: URI) {
+    return this.doCreate(resource, false);
+  }
+
+  public move(files: Required<SourceTargetPair>[], options?: { overwrite?: boolean }): Promise<FileStat[]> {
+    return this.doMoveOrCopy(files, true, options);
+  }
+
+  public copy(files: Required<SourceTargetPair>[], options?: { overwrite?: boolean }): Promise<FileStat[]> {
+    return this.doMoveOrCopy(files, false, options);
+  }
+
+  public async delete(resources: URI[], options?: { useTrash?: boolean; recursive?: boolean }): Promise<void> {
+    // file operation participant
+    const files = resources.map((target) => ({ target: target.codeUri }));
+    await this.runOperationParticipant(files, FileOperation.DELETE);
+
+    // before events
+    const event = { correlationId: this.correlationIds++, operation: FileOperation.DELETE, files };
+    await this._onWillRunWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+    // now actually delete from disk
+    try {
+      for (const resource of resources) {
+        // TODO: support recursive option
+        await this.fileService.delete(resource.toString(), { moveToTrash: options?.useTrash });
+      }
+    } catch (error) {
+      // error event
+      await this._onDidFailWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+      throw error;
+    }
+
+    // after event
+    await this._onDidRunWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+  }
+
+  public registerFileOperationParticipant(participant: IWorkspaceFileOperationParticipant): IDisposable {
+    return this.fileOperationParticipants.registerParticipant(participant);
+  }
+
+  private runOperationParticipant(files: SourceTargetPair[], operation: FileOperation) {
+    return this.fileOperationParticipants.participate(files, operation);
+  }
+
+  private async doMoveOrCopy(
+    files: Required<SourceTargetPair>[],
+    move: boolean,
+    options?: { overwrite?: boolean },
+  ): Promise<FileStat[]> {
+    const overwrite = options?.overwrite;
+    const stats: FileStat[] = [];
+
+    // file operation participant
+    await this.runOperationParticipant(files, move ? FileOperation.MOVE : FileOperation.COPY);
+
+    // before event
+    const event = {
+      correlationId: this.correlationIds++,
+      operation: move ? FileOperation.MOVE : FileOperation.COPY,
+      files,
+    };
+    await this._onWillRunWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+    try {
+      for (const { source, target } of files) {
+        // now we can rename the source to target via file operation
+        if (move) {
+          stats.push(await this.fileService.move(source.toString(), target.toString(), { overwrite }));
+        } else {
+          stats.push(await this.fileService.copy(source.toString(), target.toString(), { overwrite }));
+        }
+      }
+    } catch (error) {
+      // error event
+      await this._onDidFailWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+      throw error;
+    }
+
+    // after event
+    await this._onDidRunWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+    return stats;
+  }
+
+  private async doCreate(resource: URI, isFile: boolean, content?: string, options?: { overwrite?: boolean }) {
+    // file operation participant
+    await this.runOperationParticipant([{ target: resource.codeUri }], FileOperation.CREATE);
+    // before events
+    const event = {
+      correlationId: this.correlationIds++,
+      operation: FileOperation.CREATE,
+      files: [{ target: resource.codeUri }],
+    };
+    await this._onWillRunWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+    // now actually create on disk
+    let stat: FileStat;
+    try {
+      if (isFile) {
+        stat = await this.fileService.createFile(resource.toString(), { overwrite: options?.overwrite, content });
+      } else {
+        stat = await this.fileService.createFolder(resource.toString());
+      }
+    } catch (error) {
+      // error event
+      await this._onDidFailWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+      throw error;
+    }
+
+    // after event
+    await this._onDidRunWorkspaceFileOperation.fireAsync(event, CancellationToken.None);
+
+    return stat;
+  }
+}

package/src/common/index.ts

@@ -0,0 +1,151 @@
+import {
+  Uri,
+  URI,
+  IRange,
+  BasicEvent,
+  FileStat,
+  CancellationToken,
+  WaitUntilEvent,
+  IDisposable,
+  Event,
+} from '@opensumi/ide-core-common';
+// eslint-disable-next-line import/no-restricted-paths
+import type { EndOfLineSequence } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+import type { IBulkEditService } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/services/bulkEditService';
+
+// 对文件位置(添加，删除，移动, 复制)
+export interface IResourceFileEdit {
+  oldResource?: URI;
+  newResource?: URI;
+  options: {
+    overwrite?: boolean;
+    ignoreIfNotExists?: boolean;
+    ignoreIfExists?: boolean;
+    recursive?: boolean;
+    showInEditor?: boolean;
+    isDirectory?: boolean;
+    copy?: boolean;
+    content?: string;
+  };
+}
+
+// 对文件内容的编辑
+export interface IResourceTextEdit {
+  resource: URI;
+  versionId?: number; // monaco's version id
+  textEdit: ITextEdit;
+  options?: {
+    openDirtyInEditor?: boolean;
+    dirtyIfInEditor?: boolean;
+  };
+}
+
+export interface ITextEdit {
+  range: IRange;
+  text: string;
+  eol?: EndOfLineSequence;
+}
+
+export interface IWorkspaceEdit {
+  edits: Array<IResourceFileEdit | IResourceTextEdit>;
+}
+
+export const IWorkspaceEditService = Symbol('IWorkspaceEditService');
+
+export interface IWorkspaceEditService {
+  apply(edit: IWorkspaceEdit): Promise<void>;
+
+  // 回复最上层的文件变更
+  revertTopFileEdit(): Promise<void>;
+}
+
+export const IWorkspaceFileService = Symbol('IWorkspaceFileService');
+
+// 区分开 monaco 内部的 IBulkEditServiceShape
+export const IBulkEditServiceShape = Symbol('IBulkEditServiceShape');
+export type IBulkEditServiceShape = IBulkEditService;
+
+export const enum FileOperation {
+  CREATE,
+  DELETE,
+  MOVE,
+  COPY,
+}
+
+export const FILE_OPERATION_TIMEOUT = 5000;
+
+export interface SourceTargetPair {
+  /**
+   * The source resource that is defined for move operations.
+   */
+  readonly source?: Uri;
+
+  /**
+   * The target resource the event is about.
+   */
+  readonly target: Uri;
+}
+
+/**
+ * not supported yet
+ */
+export interface IFileOperationUndoRedoInfo {
+  /**
+   * Id of the undo group that the file operation belongs to.
+   */
+  undoRedoGroupId?: number;
+
+  /**
+   * Flag indicates if the operation is an undo.
+   */
+  isUndoing?: boolean;
+}
+
+export interface IWorkspaceFileOperationParticipant {
+  /**
+   * Participate in a file operation of working copies. Allows to
+   * change the working copies before they are being saved to disk.
+   */
+  participate(
+    files: SourceTargetPair[],
+    operation: FileOperation,
+    undoInfo: IFileOperationUndoRedoInfo | undefined,
+    timeout: number,
+    token: CancellationToken,
+  ): Promise<void>;
+}
+
+export interface WorkspaceFileEvent extends WaitUntilEvent {
+  /**
+   * An identifier to correlate the operation through the
+   * different event types (before, after, error).
+   */
+  readonly correlationId: number;
+
+  /**
+   * The file operation that is taking place.
+   */
+  readonly operation: FileOperation;
+
+  /**
+   * The array of source/target pair of files involved in given operation.
+   */
+  readonly files: SourceTargetPair[];
+}
+
+export interface IWorkspaceFileService {
+  readonly onWillRunWorkspaceFileOperation: Event<WorkspaceFileEvent>;
+  readonly onDidFailWorkspaceFileOperation: Event<WorkspaceFileEvent>;
+  readonly onDidRunWorkspaceFileOperation: Event<WorkspaceFileEvent>;
+
+  create(resource: URI, contents?: string, options?: { overwrite?: boolean }): Promise<FileStat>;
+  createFolder(resource: URI): Promise<FileStat>;
+  move(files: Required<SourceTargetPair>[], options?: { overwrite?: boolean }): Promise<FileStat[]>;
+  copy(files: Required<SourceTargetPair>[], options?: { overwrite?: boolean }): Promise<FileStat[]>;
+  delete(resources: URI[], options?: { useTrash?: boolean; recursive?: boolean }): Promise<void>;
+
+  registerFileOperationParticipant(participant: IWorkspaceFileOperationParticipant): IDisposable;
+}
+
+export class WorkspaceEditDidRenameFileEvent extends BasicEvent<{ oldUri: URI; newUri: URI }> {}
+export class WorkspaceEditDidDeleteFileEvent extends BasicEvent<{ oldUri: URI }> {}