@opensumi/ide-editor 2.21.13 → 2.22.0

package/src/browser/format/format.service.ts

@@ -0,0 +1,95 @@
+import { Injector, Injectable, Autowired, INJECTOR_TOKEN } from '@opensumi/di';
+import { CancellationToken, ILogger } from '@opensumi/ide-core-common';
+import { languageFeaturesService } from '@opensumi/ide-monaco/lib/browser/monaco-api/languages';
+import { Range } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
+import {
+  DocumentFormattingEditProvider,
+  DocumentRangeFormattingEditProvider,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/common/languages';
+import {
+  getRealAndSyntheticDocumentFormattersOrdered,
+  FormattingMode,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/format/browser/format';
+import { FormattingEdit } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/format/browser/formattingEdit';
+
+import { WorkbenchEditorService } from '../types';
+import { WorkbenchEditorServiceImpl } from '../workbench-editor.service';
+
+import { FormattingSelector } from './formatterSelect';
+
+@Injectable()
+export class DocumentFormatService {
+  @Autowired(ILogger)
+  private readonly logger: ILogger;
+
+  @Autowired(WorkbenchEditorService)
+  private workbenchEditorService: WorkbenchEditorServiceImpl;
+
+  @Autowired(INJECTOR_TOKEN)
+  injector: Injector;
+
+  async formatDocumentWith() {
+    const model = this.workbenchEditorService.currentEditor?.monacoEditor.getModel();
+    if (model) {
+      const formatterProviders = getRealAndSyntheticDocumentFormattersOrdered(
+        languageFeaturesService.documentFormattingEditProvider,
+        languageFeaturesService.documentRangeFormattingEditProvider,
+        model,
+      );
+      const selector = this.injector.get(FormattingSelector);
+      const formatter = await selector.select(formatterProviders, model, FormattingMode.Explicit, true);
+      if (formatter) {
+        try {
+          const edits = await (formatter as DocumentFormattingEditProvider).provideDocumentFormattingEdits(
+            model,
+            model.getFormattingOptions(),
+            CancellationToken.None,
+          );
+          if (edits) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            FormattingEdit.execute(this.workbenchEditorService.currentEditor?.monacoEditor!, edits, true);
+          }
+        } catch (err) {
+          this.logger.error('execute format document with error', err);
+        }
+      }
+    }
+  }
+
+  async formatSelectionWith() {
+    if (!this.workbenchEditorService.currentEditor?.monacoEditor.hasModel()) {
+      return;
+    }
+    const model = this.workbenchEditorService.currentEditor?.monacoEditor.getModel();
+    if (model) {
+      let range: Range | null | undefined = this.workbenchEditorService.currentEditor?.monacoEditor.getSelection();
+      if (range?.isEmpty()) {
+        range = new Range(
+          range.startLineNumber,
+          1,
+          range.startLineNumber,
+          model.getLineMaxColumn(range.startLineNumber),
+        );
+      }
+      const formatterProviders = languageFeaturesService.documentRangeFormattingEditProvider.ordered(model);
+      const selector = this.injector.get(FormattingSelector);
+      const formatter = await selector.select(formatterProviders, model, FormattingMode.Explicit, true);
+      if (formatter) {
+        try {
+          const edits = await (formatter as DocumentRangeFormattingEditProvider).provideDocumentRangeFormattingEdits(
+            model,
+            range!,
+            model.getFormattingOptions(),
+            CancellationToken.None,
+          );
+          if (edits) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            FormattingEdit.execute(this.workbenchEditorService.currentEditor?.monacoEditor!, edits, true);
+          }
+        } catch (err) {
+          this.logger.error('execute format document with error', err);
+        }
+      }
+    }
+  }
+}

package/src/browser/format/formatterSelect.ts

@@ -0,0 +1,82 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { QuickPickService, localize, PreferenceService, URI, PreferenceScope } from '@opensumi/ide-core-browser';
+import { ITextModel } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+import { FormattingMode } from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/format/browser/format';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import { IEditorDocumentModelService } from '../doc-model/types';
+
+type IProvider = monaco.languages.DocumentFormattingEditProvider | monaco.languages.DocumentRangeFormattingEditProvider;
+
+@Injectable()
+export class FormattingSelector {
+  @Autowired(QuickPickService)
+  private quickPickService: QuickPickService;
+
+  @Autowired(PreferenceService)
+  private preferenceService: PreferenceService;
+
+  @Autowired(IEditorDocumentModelService)
+  private modelService: IEditorDocumentModelService;
+
+  async select(
+    formatters: Array<
+      monaco.languages.DocumentFormattingEditProvider | monaco.languages.DocumentRangeFormattingEditProvider
+    >,
+    document: ITextModel,
+    mode: FormattingMode,
+    forceSelect = false,
+  ): Promise<
+    monaco.languages.DocumentFormattingEditProvider | monaco.languages.DocumentRangeFormattingEditProvider | undefined
+  > {
+    const docRef = this.modelService.getModelReference(URI.from(document.uri.toJSON()));
+    if (!docRef) {
+      return;
+    }
+    const languageId = docRef.instance.languageId;
+    docRef.dispose();
+    let preferred;
+    if (!forceSelect) {
+      preferred = (this.preferenceService.get<{ [key: string]: string }>('editor.preferredFormatter') || {})[
+        languageId
+      ];
+    }
+
+    const elements: { [key: string]: IProvider } = {};
+    formatters.forEach((provider: IProvider) => {
+      if (provider.extensionId) {
+        elements[provider.extensionId] = provider;
+      }
+    });
+
+    if (preferred && !forceSelect) {
+      const idx = formatters.findIndex((provider: IProvider) => provider.extensionId === preferred);
+      if (idx >= 0) {
+        return formatters[idx];
+      }
+    } else if (formatters.length < 2 && !forceSelect) {
+      return formatters[0];
+    }
+
+    if (mode === FormattingMode.Explicit) {
+      const selected = await this.quickPickService.show(
+        Object.keys(elements).map((k) => ({
+          label: elements[k].displayName!,
+          value: elements[k].extensionId,
+        })),
+        { placeholder: localize('editor.format.chooseFormatter') },
+      );
+      if (selected) {
+        const config = this.preferenceService.get<{ [key: string]: string }>('editor.preferredFormatter') || {};
+        this.preferenceService.set(
+          'editor.preferredFormatter',
+          { ...config, [languageId]: selected },
+          PreferenceScope.User,
+        );
+        return elements[selected];
+      }
+    } else {
+      return undefined;
+    }
+  }
+}

package/src/browser/fs-resource/file-tree-set.ts

@@ -0,0 +1,126 @@
+/**
+ * 对于 tree-like 的结构，希望父节点被删除/更新时，能影响到子节点
+ */
+export class FileTreeNode {
+  public readonly key: string;
+
+  private _children: Map<string, FileTreeNode> | undefined;
+
+  private _disposed = false;
+
+  private _onDisposed: () => void;
+
+  private get children() {
+    if (!this._children) {
+      this._children = new Map();
+    }
+    return this._children!;
+  }
+
+  constructor(public readonly path: string, public readonly parent?: FileTreeNode, private separator: string = '/') {
+    if (parent) {
+      this.key = parent.key + this.separator + path;
+    } else {
+      this.key = path;
+    }
+  }
+
+  public bindOnDispose(callback: () => void) {
+    this._onDisposed = callback;
+  }
+
+  addChild(path: string): FileTreeNode {
+    const node = new FileTreeNode(path, this, this.separator);
+    this.children.set(path, node);
+    return node;
+  }
+
+  getAllDescendants(): FileTreeNode[] {
+    if (!this._children) {
+      return [this];
+    } else {
+      const result: FileTreeNode[] = [this];
+      this.children.forEach((c) => {
+        result.push(...c.getAllDescendants());
+      });
+      return result;
+    }
+  }
+
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+    if (this.parent) {
+      this.parent.children.delete(this.path);
+      if (this.parent.children.size === 0) {
+        this.parent.dispose();
+      }
+    }
+    if (this._onDisposed) {
+      this._onDisposed();
+    }
+    this._disposed = true;
+  }
+}
+
+export class FileTreeSet<T = any> {
+  private separator: string;
+  constructor(isWindows = false) {
+    this.separator = isWindows ? '\\' : '/';
+  }
+
+  private nodes: Map<string, FileTreeNode> = new Map();
+
+  add<T>(path: string) {
+    const segments = path.split(this.separator);
+    let p: string | undefined;
+    let currentNode: FileTreeNode | undefined;
+    for (const seg of segments) {
+      if (p === undefined) {
+        p = seg;
+      } else {
+        p += this.separator + seg;
+      }
+      let node: FileTreeNode;
+      if (this.nodes.has(p)) {
+        node = this.nodes.get(p)!;
+      } else {
+        if (currentNode) {
+          node = currentNode!.addChild(seg);
+        } else {
+          node = new FileTreeNode(seg, undefined, this.separator);
+        }
+        node.bindOnDispose(() => {
+          this.nodes.delete(node.key);
+        });
+        this.nodes.set(node.key, node);
+      }
+      currentNode = node;
+    }
+  }
+
+  /**
+   * 返回所有被影响的子节点
+   * @param path
+   */
+  delete(path: string): string[] {
+    const effected = this.effects(path);
+    effected.forEach((e) => {
+      const node = this.nodes.get(e);
+      if (node) {
+        node.dispose();
+      }
+    });
+    return effected;
+  }
+
+  effects(path: string): string[] {
+    const target = this.nodes.get(path);
+    if (!target) {
+      return [];
+    } else {
+      return target!.getAllDescendants().map((n) => n.key);
+    }
+  }
+}

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

@@ -0,0 +1,213 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  Emitter,
+  URI,
+  Event,
+  IApplicationService,
+  FileChangeType,
+  OperatingSystem,
+  IEditorDocumentChange,
+  IEditorDocumentModelSaveResult,
+  PreferenceService,
+  getLanguageIdFromMonaco,
+  EncodingRegistry,
+  UTF8_with_bom,
+  UTF8,
+  detectEncodingFromBuffer,
+  SaveTaskResponseState,
+} from '@opensumi/ide-core-browser';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+import { EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+
+import { IEditorDocumentModelContentProvider } from '../doc-model/types';
+import { EditorPreferences } from '../preference/schema';
+
+export interface ReadEncodingOptions {
+  /**
+   * The optional encoding parameter allows to specify the desired encoding when resolving
+   * the contents of the file.
+   */
+  encoding?: string;
+
+  /**
+   * The optional guessEncoding parameter allows to guess encoding from content of the file.
+   */
+  autoGuessEncoding?: boolean;
+}
+
+/**
+ * 通用的用来处理 FileSystem 提供的文档
+ * 可以 extend 这个来添加更强的能力，如 file-scheme 中的 file-doc
+ */
+@Injectable()
+export class BaseFileSystemEditorDocumentProvider implements IEditorDocumentModelContentProvider {
+  protected _onDidChangeContent: Emitter<URI> = new Emitter();
+
+  public onDidChangeContent: Event<URI> = this._onDidChangeContent.event;
+
+  protected _fileContentMd5OnBrowserFs: Set<string> = new Set();
+
+  private _detectedEncodingMap = new Map<string, string>();
+
+  @Autowired(IFileServiceClient)
+  protected readonly fileServiceClient: IFileServiceClient;
+
+  @Autowired(EditorPreferences)
+  protected readonly editorPreferences: EditorPreferences;
+
+  @Autowired(IApplicationService)
+  protected readonly applicationService: IApplicationService;
+
+  @Autowired(PreferenceService)
+  protected readonly preferenceService: PreferenceService;
+
+  @Autowired(EncodingRegistry)
+  encodingRegistry: EncodingRegistry;
+
+  constructor() {
+    this.fileServiceClient.onFilesChanged((changes) => {
+      changes.forEach((change) => {
+        if (this._fileContentMd5OnBrowserFs.has(change.uri)) {
+          if (change.type === FileChangeType.ADDED || change.type === FileChangeType.UPDATED) {
+            this._onDidChangeContent.fire(new URI(change.uri));
+          }
+        }
+      });
+    });
+  }
+
+  handlesScheme(scheme: string) {
+    return this.fileServiceClient.handlesScheme(scheme);
+  }
+
+  provideEncoding(uri: URI) {
+    return this._detectedEncodingMap.get(uri.toString()) || 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 read(uri: URI, options: ReadEncodingOptions): Promise<{ encoding: string; content: string }> {
+    const { content: buffer } = await this.fileServiceClient.readFile(uri.toString());
+
+    const guessEncoding =
+      options.autoGuessEncoding ||
+      this.preferenceService.get<boolean>(
+        'files.autoGuessEncoding',
+        undefined,
+        uri.toString(),
+        getLanguageIdFromMonaco(uri)!,
+      );
+    const detected = await detectEncodingFromBuffer(buffer, guessEncoding);
+    detected.encoding = await this.getReadEncoding(uri, options, detected.encoding);
+
+    const content = buffer.toString(detected.encoding);
+
+    const uriString = uri.toString();
+
+    this._detectedEncodingMap.set(uriString, detected.encoding);
+
+    // 记录表示这个文档被[这个editorDocumentProvider]引用了
+    this._fileContentMd5OnBrowserFs.add(uriString);
+
+    return {
+      encoding: detected.encoding || UTF8,
+      content,
+    };
+  }
+
+  async provideEditorDocumentModelContent(uri: URI, encoding: string) {
+    // TODO: 这部分要优化成buffer获取（长期来看是stream获取，encoding在哪一层做？）
+    // 暂时还是使用 resolveContent 内提供的 decode 功能
+    // 之后 encoding 做了分层之后和其他的需要 decode 的地方一起改
+    return (await this.read(uri, { encoding })).content;
+  }
+
+  async isReadonly(uri: URI): Promise<boolean> {
+    const readonlyFiles: string[] = this.editorPreferences['editor.readonlyFiles'];
+    if (readonlyFiles && readonlyFiles.length) {
+      for (const file of readonlyFiles) {
+        if (
+          uri.isEqual(URI.file(file)) ||
+          uri.matchGlobPattern(file) ||
+          uri.toString().endsWith(file.replace('./', ''))
+        ) {
+          return true;
+        }
+      }
+    }
+    return this.fileServiceClient.isReadonly(uri.toString());
+  }
+
+  async saveDocumentModel(
+    uri: URI,
+    content: string,
+    baseContent: string,
+    changes: IEditorDocumentChange[],
+    encoding: string,
+    ignoreDiff = false,
+  ): Promise<IEditorDocumentModelSaveResult> {
+    // 默认的文件系统都直接存 content
+    try {
+      const fileStat = await this.fileServiceClient.getFileStat(uri.toString());
+      if (!fileStat) {
+        await this.fileServiceClient.createFile(uri.toString(), { content, overwrite: true, encoding });
+      } else {
+        await this.fileServiceClient.setContent(fileStat, content, { encoding });
+      }
+      return {
+        state: SaveTaskResponseState.SUCCESS,
+      };
+    } catch (e) {
+      return {
+        state: SaveTaskResponseState.ERROR,
+        errorMessage: e.message,
+      };
+    }
+  }
+
+  onDidDisposeModel(uri: URI) {
+    this._fileContentMd5OnBrowserFs.delete(uri.toString());
+  }
+
+  async guessEncoding(uri: URI) {
+    return (await this.read(uri, { autoGuessEncoding: true })).encoding;
+  }
+
+  protected getReadEncoding(
+    resource: URI,
+    options: ReadEncodingOptions | undefined,
+    detectedEncoding: string | null,
+  ): Promise<string> {
+    let preferredEncoding: string | undefined;
+
+    // Encoding passed in as option
+    if (options?.encoding) {
+      if (detectedEncoding === UTF8_with_bom && options.encoding === UTF8) {
+        preferredEncoding = UTF8_with_bom; // indicate the file has BOM if we are to resolve with UTF 8
+      } else {
+        preferredEncoding = options.encoding; // give passed in encoding highest priority
+      }
+    } else if (detectedEncoding) {
+      preferredEncoding = detectedEncoding;
+    }
+
+    return this.getEncodingForResource(resource, preferredEncoding);
+  }
+
+  protected async getEncodingForResource(resource: URI, preferredEncoding?: string): Promise<string> {
+    return this.encodingRegistry.getEncodingForResource(resource, preferredEncoding);
+  }
+}