@opensumi/ide-editor 2.21.13 → 2.22.0

package/src/browser/fs-resource/fs-resource.ts

@@ -0,0 +1,247 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import {
+  OperatingSystem,
+  URI,
+  MaybePromise,
+  WithEventBus,
+  localize,
+  formatLocalize,
+  MessageType,
+  LRUMap,
+  IApplicationService,
+} from '@opensumi/ide-core-browser';
+import { LabelService } from '@opensumi/ide-core-browser/lib/services';
+import { FileChangeType, path } from '@opensumi/ide-core-common';
+import { IFileServiceClient, FileStat } from '@opensumi/ide-file-service/lib/common';
+import { IDialogService } from '@opensumi/ide-overlay';
+
+import { IResourceProvider, IResource, ResourceNeedUpdateEvent, AskSaveResult } from '../../common';
+import { DIFF_SCHEME } from '../../common';
+import { IEditorDocumentModelService } from '../doc-model/types';
+
+import { FileTreeSet } from './file-tree-set';
+
+const { Path } = path;
+
+@Injectable()
+export class FileSystemResourceProvider extends WithEventBus implements IResourceProvider {
+  private static SUBNAME_LIMIT = 20;
+
+  @Autowired()
+  protected labelService: LabelService;
+
+  @Autowired(IFileServiceClient)
+  protected fileServiceClient: IFileServiceClient;
+
+  @Autowired(IDialogService)
+  protected dialogService: IDialogService;
+
+  @Autowired(IEditorDocumentModelService)
+  protected documentModelService: IEditorDocumentModelService;
+
+  @Autowired(IApplicationService)
+  protected applicationService: IApplicationService;
+
+  cachedFileStat = new LRUMap<string, FileStat | undefined>(200, 100);
+
+  private involvedFiles: FileTreeSet;
+
+  private ready: Promise<void>;
+
+  constructor() {
+    super();
+    this.ready = this.init();
+    this.listen();
+  }
+
+  async init() {
+    const os = await this.applicationService.getBackendOS();
+    this.involvedFiles = new FileTreeSet(os === OperatingSystem.Windows);
+  }
+
+  handlesUri(uri: URI): number {
+    const scheme = uri.scheme;
+    if (this.fileServiceClient.handlesScheme(scheme)) {
+      return 10;
+    } else {
+      return -1;
+    }
+  }
+
+  protected listen() {
+    this.fileServiceClient.onFilesChanged((e) => {
+      e.forEach((change) => {
+        if (change.type === FileChangeType.ADDED || change.type === FileChangeType.DELETED) {
+          // 对于文件夹的删除，做要传递给子文件
+          const effectedPaths = this.involvedFiles?.effects(new URI(change.uri).codeUri.fsPath);
+          effectedPaths.forEach((p) => {
+            const effected = URI.file(p);
+            this.cachedFileStat.delete(effected.toString());
+            this.eventBus.fire(new ResourceNeedUpdateEvent(effected));
+          });
+        } else {
+          // Linux下，可能 update 事件代表了 create
+          // 此时如果 cached 是undefined，就更新
+          if (this.cachedFileStat.has(change.uri) && this.cachedFileStat.get(change.uri) === undefined) {
+            this.cachedFileStat.delete(change.uri);
+            this.eventBus.fire(new ResourceNeedUpdateEvent(new URI(change.uri)));
+          }
+        }
+      });
+    });
+    this.labelService.onDidChange((uri) => {
+      if (uri.codeUri.fsPath && this.involvedFiles?.effects(uri.codeUri.fsPath)) {
+        this.eventBus.fire(new ResourceNeedUpdateEvent(uri));
+      }
+    });
+  }
+
+  async getFileStat(uri: string) {
+    if (!this.cachedFileStat.has(uri)) {
+      this.cachedFileStat.set(uri, await this.fileServiceClient.getFileStat(uri.toString()));
+    }
+    return this.cachedFileStat.get(uri);
+  }
+
+  async provideResource(uri: URI): Promise<IResource<any>> {
+    // 获取文件类型 getFileType: (path: string) => string
+    await this.ready;
+    this.involvedFiles.add(uri.codeUri.fsPath);
+    return Promise.all([
+      this.getFileStat(uri.toString()),
+      this.labelService.getName(uri),
+      this.labelService.getIcon(uri),
+    ] as const).then(([stat, name, icon]) => ({
+      name: stat ? name : name + localize('file.resource-deleted', '(已删除)'),
+      icon,
+      uri,
+      metadata: null,
+      deleted: !stat,
+      supportsRevive: true,
+    }));
+  }
+
+  provideResourceSubname(resource: IResource, groupResources: IResource[]): string | null {
+    const shouldDiff: URI[] = [];
+    for (const res of groupResources) {
+      if (
+        this.fileServiceClient.handlesScheme(res.uri.scheme) &&
+        res.uri.displayName === resource.uri.displayName &&
+        res !== resource
+      ) {
+        // 存在file协议的相同名称的文件
+        shouldDiff.push(res.uri);
+      }
+    }
+    if (shouldDiff.length > 0) {
+      const tail = getMinimalDiffPath(resource.uri, shouldDiff);
+      if (tail.startsWith(Path.separator)) {
+        // 说明当前为全路径
+        if (tail.length > FileSystemResourceProvider.SUBNAME_LIMIT) {
+          return '...' + tail.slice(tail.length - FileSystemResourceProvider.SUBNAME_LIMIT);
+        } else {
+          return tail;
+        }
+      } else {
+        return '...' + Path.separator + getMinimalDiffPath(resource.uri, shouldDiff);
+      }
+    } else {
+      return null;
+    }
+  }
+
+  onDisposeResource(resource) {
+    this.involvedFiles?.delete(resource.uri.codeUri.fsPath);
+    this.cachedFileStat.delete(resource.uri.toString());
+  }
+  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, openedResources: IResource[][]): Promise<boolean> {
+    let count = 0;
+    for (const resources of openedResources) {
+      for (const r of resources) {
+        if (r.uri.scheme === DIFF_SCHEME && r.metadata && r.metadata.modified.toString() === resource.uri.toString()) {
+          count++;
+        }
+        if (this.fileServiceClient.handlesScheme(r.uri.scheme) && r.uri.toString() === resource.uri.toString()) {
+          count++;
+        }
+        if (count > 1) {
+          return true;
+        }
+      }
+    }
+    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', "Don't Save")]: AskSaveResult.REVERT,
+      [localize('file.prompt.save', 'Save')]: AskSaveResult.SAVE,
+      [localize('file.prompt.cancel', 'Cancel')]: AskSaveResult.CANCEL,
+    };
+    const selection = await this.dialogService.open(
+      formatLocalize('saveChangesMessage', resource.name),
+      MessageType.Info,
+      Object.keys(buttons),
+    );
+    const result = buttons[selection!];
+    return this.close(resource, result);
+  }
+}
+
+/**
+ * 找到 source 文件 url 和中从末尾开始和 target 不一样的 path
+ * @param source
+ * @param targets
+ */
+function getMinimalDiffPath(source: URI, targets: URI[]): string {
+  const sourceDirPartsReverse = source.path.dir.toString().split(Path.separator).reverse();
+  const targetDirPartsReverses = targets.map((target) => target.path.dir.toString().split(Path.separator).reverse());
+  for (let i = 0; i < sourceDirPartsReverse.length; i++) {
+    let foundSame = false;
+    for (const targetDirPartsReverse of targetDirPartsReverses) {
+      if (targetDirPartsReverse[i] === sourceDirPartsReverse[i]) {
+        foundSame = true;
+        break;
+      }
+    }
+    if (!foundSame) {
+      return sourceDirPartsReverse
+        .slice(0, i + 1)
+        .reverse()
+        .join(Path.separator);
+    }
+  }
+  return sourceDirPartsReverse.reverse().join(Path.separator);
+}

package/src/browser/fs-resource/index.ts

@@ -0,0 +1,27 @@
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-browser';
+
+
+import { ResourceService } from '../../common';
+import { IEditorDocumentModelContentRegistry } from '../doc-model/types';
+import { BrowserEditorContribution } from '../types';
+
+import { BaseFileSystemEditorDocumentProvider } from './fs-editor-doc';
+import { FileSystemResourceProvider } from './fs-resource';
+
+@Domain(BrowserEditorContribution)
+export class FileSystemResourceContribution implements BrowserEditorContribution {
+  @Autowired(FileSystemResourceProvider)
+  fsResourceProvider: FileSystemResourceProvider;
+
+  @Autowired(BaseFileSystemEditorDocumentProvider)
+  fsDocProvider: BaseFileSystemEditorDocumentProvider;
+
+  registerResource(registry: ResourceService) {
+    registry.registerResourceProvider(this.fsResourceProvider);
+  }
+
+  registerEditorDocumentModelContentProvider(registry: IEditorDocumentModelContentRegistry) {
+    registry.registerEditorDocumentModelContentProvider(this.fsDocProvider);
+  }
+}

package/src/browser/grid/grid.service.ts

@@ -0,0 +1,288 @@
+import { IDisposable, IEventBus, MaybeNull, Emitter } from '@opensumi/ide-core-browser';
+import { makeRandomHexString } from '@opensumi/ide-core-common';
+
+import { IEditorGroup, IEditorGroupState, Direction } from '../../common';
+import { GridResizeEvent } from '../types';
+
+export const editorGridUid = new Set();
+
+export class EditorGrid implements IDisposable {
+  public editorGroup: IGridEditorGroup | null = null;
+
+  public children: EditorGrid[] = [];
+
+  public splitDirection: SplitDirection | undefined;
+
+  protected readonly _onDidGridStateChange = new Emitter<void>();
+
+  public readonly onDidGridStateChange = this._onDidGridStateChange.event;
+
+  protected readonly _onDidGridAndDesendantStateChange = new Emitter<void>();
+
+  public readonly onDidGridAndDesendantStateChange = this._onDidGridAndDesendantStateChange.event;
+
+  public readonly uid: string;
+
+  constructor(public parent?: EditorGrid) {
+    let uid = makeRandomHexString(5);
+    while (editorGridUid.has(uid)) {
+      uid = makeRandomHexString(5);
+    }
+    this.uid = uid;
+    editorGridUid.add(uid);
+    this.onDidGridStateChange(() => {
+      this._onDidGridAndDesendantStateChange.fire();
+      this.parent?._onDidGridAndDesendantStateChange.fire();
+    });
+  }
+
+  setEditorGroup(editorGroup: IGridEditorGroup) {
+    this.editorGroup = editorGroup;
+    editorGroup.grid = this;
+    this.splitDirection = undefined;
+  }
+  // 当前 grid 作为 parent ，原有 grid 与新增 grid 作为子元素
+  private generateSplitParent(direction: SplitDirection, editorGroup: IGridEditorGroup, before?: boolean) {
+    this.splitDirection = direction;
+    const originalChild = new EditorGrid(this);
+    originalChild.setEditorGroup(this.editorGroup!);
+    this.editorGroup = null;
+    const newGrid = new EditorGrid(this);
+    newGrid.setEditorGroup(editorGroup);
+    if (before) {
+      this.children = [newGrid, originalChild];
+    } else {
+      this.children = [originalChild, newGrid];
+    }
+    this._onDidGridStateChange.fire();
+  }
+  // 新增 grid 与当前 grid 作为同一父 grid 的子元素
+  private generateSplitSibling(editorGroup: IGridEditorGroup, before?: boolean) {
+    if (this.parent) {
+      const index = this.parent.children.indexOf(this);
+      const newGrid = new EditorGrid(this.parent);
+      newGrid.setEditorGroup(editorGroup);
+
+      if (before) {
+        this.parent.children.splice(index, 0, newGrid);
+      } else {
+        this.parent.children.splice(index + 1, 0, newGrid);
+      }
+      this.parent._onDidGridStateChange.fire();
+    }
+  }
+  public split(direction: SplitDirection, editorGroup: IGridEditorGroup, before?: boolean) {
+    // 由于split永远只会从未分割的含有editorGroup的grid发出
+    // 父元素不含有实际渲染 ui
+    if (!this.splitDirection) {
+      // 顶层 grid 且未有指定方向，生成初始父级单元
+      if (!this.parent) {
+        this.generateSplitParent(direction, editorGroup, before);
+        // 非顶层 grid
+      } else {
+        // 与父元素方向一致，则为同级子元素
+        if (this.parent.splitDirection === direction) {
+          this.generateSplitSibling(editorGroup, before);
+          // 与父元素方向不一致，则生成为父级单元
+        } else if (this.parent.splitDirection !== direction) {
+          this.generateSplitParent(direction, editorGroup, before);
+        }
+      }
+    }
+  }
+
+  public dispose() {
+    if (this.editorGroup) {
+      this.editorGroup = null;
+      if (!this.parent) {
+        return; // geng
+      }
+      const index = this.parent.children.indexOf(this);
+      this.parent.children.splice(index, 1);
+      if (this.parent.children.length === 1) {
+        this.parent.replaceBy(this.parent.children[0]);
+      }
+      this.parent._onDidGridStateChange.fire();
+    } else {
+      // 应该不会落入这里
+    }
+  }
+
+  public replaceBy(target: EditorGrid) {
+    if (target.editorGroup) {
+      this.setEditorGroup(target.editorGroup);
+    }
+    this.splitDirection = target.splitDirection;
+    this.children.splice(0, this.children.length, ...target.children.splice(0, target.children.length));
+    this.children.forEach((grid) => {
+      grid.parent = this;
+    });
+    if (this.parent) {
+      this.parent._onDidGridStateChange.fire();
+    }
+  }
+
+  public emitResizeWithEventBus(eventBus: IEventBus) {
+    eventBus.fire(new GridResizeEvent({ gridId: this.uid }));
+    this.children.forEach((c) => {
+      c.emitResizeWithEventBus(eventBus);
+    });
+  }
+
+  serialize(): IEditorGridState | null {
+    if (this.editorGroup) {
+      const editorGroupState = this.editorGroup.getState();
+      if (this.parent && editorGroupState.uris.length === 0) {
+        return null;
+      }
+      return {
+        editorGroup: editorGroupState,
+      };
+    } else {
+      if (this.parent && this.children.length === 0) {
+        return null;
+      }
+      const children = this.children.map((c) => c.serialize()).filter((c) => !!c) as IEditorGridState[];
+      if (children.length === 1) {
+        // 只有一个孩子，直接覆盖
+        return children[0];
+      }
+      return {
+        splitDirection: this.splitDirection,
+        children,
+      };
+    }
+  }
+
+  async deserialize(
+    state: IEditorGridState,
+    editorGroupFactory: () => IGridEditorGroup,
+    editorGroupRestoreStatePromises: Promise<any>[],
+  ): Promise<any> {
+    const promises: Promise<any>[] = [];
+    if (state.editorGroup) {
+      this.setEditorGroup(editorGroupFactory());
+      editorGroupRestoreStatePromises.push(this.editorGroup!.restoreState(state.editorGroup));
+    } else {
+      this.splitDirection = state.splitDirection;
+      this.children = (state.children || []).map((c) => {
+        const grid = new EditorGrid(this);
+        promises.push(grid.deserialize(c, editorGroupFactory, editorGroupRestoreStatePromises));
+        return grid;
+      });
+    }
+    return Promise.all(promises);
+  }
+
+  findGird(direction: Direction, currentIndex = 0): MaybeNull<EditorGrid> {
+    if (this.splitDirection && splitDirectionMatches(this.splitDirection, direction)) {
+      const targetIndex = currentIndex + (direction === Direction.LEFT || direction === Direction.UP ? -1 : 1);
+      if (this.children[targetIndex]) {
+        return this.children[targetIndex].getFirstLeaf();
+      }
+    }
+
+    if (!this.parent) {
+      return null;
+    } else {
+      return this.parent.findGird(direction, this.parent.children.indexOf(this));
+    }
+  }
+
+  getFirstLeaf(): MaybeNull<EditorGrid> {
+    if (this.editorGroup) {
+      return this;
+    } else {
+      if (this.children.length > 0) {
+        return this.children[0].getFirstLeaf();
+      } else {
+        return null;
+      }
+    }
+  }
+
+  sortEditorGroups(results: IEditorGroup[]) {
+    if (this.editorGroup) {
+      results.push(this.editorGroup);
+    } else {
+      if (this.children.length > 0) {
+        this.children.forEach((children) => {
+          children.sortEditorGroups(results);
+        });
+      }
+    }
+  }
+
+  move(direction: Direction) {
+    if (this.parent) {
+      if (this.parent.splitDirection === SplitDirection.Horizontal) {
+        if (direction === Direction.LEFT) {
+          const index = this.parent.children.indexOf(this);
+          if (index > 0) {
+            this.parent!.children.splice(index, 1);
+            this.parent!.children.splice(index - 1, 0, this);
+            this.parent._onDidGridStateChange.fire();
+          }
+        } else if (direction === Direction.RIGHT) {
+          const index = this.parent.children.indexOf(this);
+          if (index < this.parent.children.length) {
+            this.parent!.children.splice(index, 1);
+            this.parent!.children.splice(index + 1, 0, this);
+            this.parent._onDidGridStateChange.fire();
+          }
+        }
+      } else if (this.parent.splitDirection === SplitDirection.Vertical) {
+        if (direction === Direction.UP) {
+          const index = this.parent.children.indexOf(this);
+          if (index > 0) {
+            this.parent!.children.splice(index, 1);
+            this.parent!.children.splice(index - 1, 0, this);
+            this.parent._onDidGridStateChange.fire();
+          }
+        } else if (direction === Direction.DOWN) {
+          const index = this.parent.children.indexOf(this);
+          if (index < this.parent.children.length) {
+            this.parent!.children.splice(index, 1);
+            this.parent!.children.splice(index + 1, 0, this);
+            this.parent._onDidGridStateChange.fire();
+          }
+        }
+      }
+    }
+  }
+}
+
+export interface IEditorGridState {
+  editorGroup?: IEditorGroupState;
+  splitDirection?: SplitDirection;
+  children?: IEditorGridState[];
+}
+
+export interface IGridChild {
+  grid: EditorGrid;
+  percentage: number; // 0-100
+}
+
+export enum SplitDirection {
+  // 水平拆分
+  Horizontal = 1,
+
+  // 垂直拆分
+  Vertical = 2,
+}
+
+export interface IGridEditorGroup extends IEditorGroup {
+  grid: EditorGrid;
+}
+
+export function splitDirectionMatches(split: SplitDirection, direction: Direction): boolean {
+  if (direction === Direction.UP || direction === Direction.DOWN) {
+    return split === SplitDirection.Vertical;
+  }
+
+  if (direction === Direction.LEFT || direction === Direction.RIGHT) {
+    return split === SplitDirection.Horizontal;
+  }
+
+  return false;
+}