@opensumi/ide-editor 2.21.13 → 2.22.0

package/src/browser/diff/index.ts

@@ -0,0 +1,81 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, Domain, WithEventBus, OnEvent } from '@opensumi/ide-core-browser';
+import { LabelService } from '@opensumi/ide-core-browser/lib/services';
+
+import { IResourceProvider, IDiffResource, ResourceService, ResourceDecorationChangeEvent } from '../../common';
+import { BrowserEditorContribution, EditorComponentRegistry, EditorOpenType } from '../types';
+
+// diff URI:
+// diff://?name=tabName&original=uri1&modified=uri2
+// 例子:
+// diff://?name=a.ts(on disk)<=>a.ts&original=file://path/to/a.ts&modified=fileOnDisk://path/to/a.ts
+
+@Injectable()
+export class DiffResourceProvider extends WithEventBus implements IResourceProvider {
+  @Autowired()
+  labelService: LabelService;
+
+  @Autowired(ResourceService)
+  resourceService: ResourceService;
+
+  scheme = 'diff';
+
+  private modifiedToResource = new Map<string, URI>();
+
+  @OnEvent(ResourceDecorationChangeEvent)
+  onResourceDecorationChangeEvent(e: ResourceDecorationChangeEvent) {
+    if (e.payload.uri && this.modifiedToResource.has(e.payload.uri.toString())) {
+      this.eventBus.fire(
+        new ResourceDecorationChangeEvent({
+          uri: this.modifiedToResource.get(e.payload.uri.toString())!,
+          decoration: e.payload.decoration,
+        }),
+      );
+    }
+  }
+
+  async provideResource(uri: URI): Promise<IDiffResource> {
+    const { original, modified, name } = uri.getParsedQuery();
+    const originalUri = new URI(original);
+    const modifiedUri = new URI(modified);
+    const icon = await this.labelService.getIcon(originalUri);
+    this.modifiedToResource.set(modifiedUri.toString(), uri);
+    return {
+      name,
+      icon,
+      uri,
+      metadata: {
+        original: originalUri,
+        modified: modifiedUri,
+      },
+    };
+  }
+
+  async shouldCloseResource(resource, openedResources): Promise<boolean> {
+    const { modified } = resource.uri.getParsedQuery();
+    const modifiedUri = new URI(modified);
+    const modifiedResource = await this.resourceService.getResource(modifiedUri);
+    if (modifiedResource) {
+      return await this.resourceService.shouldCloseResource(modifiedResource, openedResources);
+    }
+    return true;
+  }
+}
+
+@Domain(BrowserEditorContribution)
+export class DefaultDiffEditorContribution implements BrowserEditorContribution {
+  @Autowired()
+  diffResourceProvider: DiffResourceProvider;
+
+  registerResource(resourceService: ResourceService): void {
+    resourceService.registerResourceProvider(this.diffResourceProvider);
+  }
+
+  registerEditorComponent(registry: EditorComponentRegistry) {
+    registry.registerEditorComponentResolver('diff', (resource: IDiffResource, results) => {
+      results.push({
+        type: EditorOpenType.diff,
+      });
+    });
+  }
+}

package/src/browser/doc-cache/empty-doc-cache.ts

@@ -0,0 +1,26 @@
+import { Injectable } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-browser';
+
+import { IDocPersistentCacheProvider, IDocStatus } from '../../common/doc-cache';
+
+/**
+ * 一个空的，什么都不做的缓存对象，提供一个空的缓存对象实现
+ */
+@Injectable()
+export class EmptyDocCacheImpl implements IDocPersistentCacheProvider {
+  hasCache(_uri: URI) {
+    return false;
+  }
+
+  isFlushed() {
+    return true;
+  }
+
+  getCache(_uri: URI) {
+    return null;
+  }
+
+  persistCache(_uri: URI, _status: IDocStatus) {
+    // nothing
+  }
+}

package/src/browser/doc-cache/index.ts

@@ -0,0 +1,2 @@
+export * from './empty-doc-cache';
+export * from './local-storage-cache';

package/src/browser/doc-cache/local-storage-cache.ts

@@ -0,0 +1,67 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-common';
+import { IWorkspaceStorageService } from '@opensumi/ide-workspace';
+
+import { IDocPersistentCacheProvider, IDocStatus, IDocCache, parseCacheValueFrom } from '../../common/doc-cache';
+
+/**
+ * 使用 LocalStorage 实现的文档缓存对象
+ */
+@Injectable()
+export class LocalStorageDocCacheImpl implements IDocPersistentCacheProvider {
+  @Autowired(IWorkspaceStorageService)
+  private storageService: IWorkspaceStorageService;
+
+  hasCache(_uri: URI) {
+    return true;
+  }
+
+  /**
+   * LocalStorage 的存储都是瞬间完成的，始终返回 true
+   */
+  isFlushed() {
+    return true;
+  }
+
+  /**
+   * 从 LocalStorage 获取缓存数据，
+   * 因为底层对象设计是异步的，所以这里也是异步的，实际上是立即返回的
+   * @param uri
+   */
+  async getCache(uri: URI) {
+    const key = this.parseKeyFrom(uri);
+    const result = await this.storageService.getData<IDocCache>(key);
+    return result || null;
+  }
+
+  /**
+   * 持久化缓存对象到 LocalStorage 中
+   * @param uri
+   * @param status
+   */
+  persistCache(uri: URI, status: IDocStatus) {
+    const key = this.parseKeyFrom(uri);
+    const cache = this.parseCacheFrom(uri, status);
+    this.storageService.setData(key, cache);
+  }
+
+  /**
+   * 从文档状态解析缓存对象
+   * @param status
+   */
+  private parseCacheFrom(uri: URI, status: IDocStatus): IDocCache | undefined {
+    if (!status.dirty || !status.changeMatrix.length) {
+      return undefined;
+    }
+
+    return {
+      path: uri.path.toString(),
+      startMD5: status.startMD5,
+      changeMatrix: status.changeMatrix.map((changes) => changes.map((change) => parseCacheValueFrom(change))),
+    };
+  }
+
+  private parseKeyFrom(uri: URI): string {
+    return `LocalStorageDocCacheImpl_${uri.toString()}`;
+  }
+}

package/src/browser/doc-model/editor-document-error.ts

@@ -0,0 +1,10 @@
+export enum EditorDocumentError {
+  // 读取缓存异常
+  READ_CACHE_ERROR = 'EditorDocumentError:READ_CACHE_ERROR',
+  // 在应用缓存内容之前，编辑器发生了内容变化
+  APPLY_CACHE_TO_DIRTY_DOCUMENT = 'EditorDocumentError:APPLY_CACHE_TO_DIRTY_DOCUMENT',
+  // 在应用缓存内容到一个不匹配的文档版本，通常发生在 MD5 计算不一样的时候
+  APPLY_CACHE_TO_DIFFERENT_DOCUMENT = 'EditorDocumentError:APPLY_CACHE_TO_DIFFERENT_DOCUMENT',
+  // Format 失败
+  FORMAT_ERROR = 'EditorDocumentError:FORMAT_ERROR',
+}

package/src/browser/doc-model/editor-document-model-service.ts

@@ -0,0 +1,346 @@
+import { Injectable, Autowired, INJECTOR_TOKEN, Injector } from '@opensumi/di';
+import {
+  URI,
+  IRef,
+  ReferenceManager,
+  IEditorDocumentChange,
+  IEditorDocumentModelSaveResult,
+  WithEventBus,
+  OnEvent,
+  StorageProvider,
+  IStorage,
+  STORAGE_SCHEMA,
+  ILogger,
+  PreferenceService,
+  ReadyEvent,
+  memoize,
+  mapToSerializable,
+  serializableToMap,
+} from '@opensumi/ide-core-browser';
+import { IHashCalculateService } from '@opensumi/ide-core-common/lib/hash-calculate/hash-calculate';
+import { EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+
+import { EditorDocumentModel } from './editor-document-model';
+import {
+  IEditorDocumentModel,
+  IEditorDocumentModelContentRegistry,
+  IEditorDocumentModelService,
+  EditorDocumentModelOptionExternalUpdatedEvent,
+  EditorDocumentModelCreationEvent,
+  IPreferredModelOptions,
+} from './types';
+
+export const EDITOR_DOCUMENT_MODEL_STORAGE: URI = new URI('editor-doc').withScheme(STORAGE_SCHEMA.SCOPE);
+
+export const EDITOR_DOC_OPTIONS_PREF_KEY = 'editor_doc_pref';
+
+@Injectable()
+export class EditorDocumentModelServiceImpl extends WithEventBus implements IEditorDocumentModelService {
+  @Autowired(IEditorDocumentModelContentRegistry)
+  contentRegistry: IEditorDocumentModelContentRegistry;
+
+  @Autowired(INJECTOR_TOKEN)
+  injector: Injector;
+
+  @Autowired(StorageProvider)
+  getStorage: StorageProvider;
+
+  @Autowired(ILogger)
+  logger: ILogger;
+
+  @Autowired(PreferenceService)
+  preferenceService: PreferenceService;
+
+  @Autowired(IHashCalculateService)
+  private readonly hashCalculateService: IHashCalculateService;
+
+  private storage: IStorage;
+
+  private editorDocModels = new Map<string, EditorDocumentModel>();
+
+  private creatingEditorModels = new Map<string, Promise<EditorDocumentModel>>();
+
+  private _modelReferenceManager: ReferenceManager<EditorDocumentModel>;
+
+  private _modelsToDispose = new Set<string>();
+
+  private preferredModelOptions = new Map<string, IPreferredModelOptions>();
+
+  private _ready = new ReadyEvent<void>();
+
+  constructor() {
+    super();
+    this._modelReferenceManager = new ReferenceManager<EditorDocumentModel>((key: string) => {
+      if (this._modelsToDispose.has(key)) {
+        this._modelsToDispose.delete(key);
+      }
+      // this.getOrCreateModel 的第二个参数是 encoding, 实际上没地方能传进去
+      // ReferenceManager 的构造参数 factory 只有一个入参
+      return this.getOrCreateModel(key);
+    });
+    this._modelReferenceManager.onReferenceAllDisposed((key: string) => {
+      this._delete(key);
+    });
+    this._modelReferenceManager.onInstanceCreated((model) => {
+      this.eventBus.fire(
+        new EditorDocumentModelCreationEvent({
+          uri: model.uri,
+          languageId: model.languageId,
+          eol: model.eol,
+          encoding: model.encoding,
+          content: model.getText(),
+          readonly: model.readonly,
+          versionId: model.getMonacoModel().getVersionId(),
+        }),
+      );
+    });
+    this.addDispose(
+      this.preferenceService.onPreferenceChanged((e) => {
+        if (e.preferenceName === 'editor.detectIndentation') {
+          this.editorDocModels.forEach((m) => {
+            m.updateOptions({});
+          });
+        }
+      }),
+    );
+  }
+
+  private _delete(uri: string | URI): void {
+    const modelDisposeDebounceTime = this.preferenceService.get<number>('editor.modelDisposeTime', 3000);
+    // debounce
+    this._modelsToDispose.add(uri.toString());
+    let timer: number | null = null;
+    const disposer = this.addDispose({
+      dispose: () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      },
+    });
+    timer = window.setTimeout(() => {
+      disposer.dispose();
+      timer = null;
+      if (this._modelsToDispose.has(uri.toString())) {
+        this._doDelete(uri.toString());
+      }
+    }, modelDisposeDebounceTime);
+  }
+
+  private _doDelete(uri: string) {
+    const doc = this.editorDocModels.get(uri);
+    // dirty 的 document 不 dispose
+    if (doc && (!doc.dirty || doc.disposeEvenDirty)) {
+      doc.dispose();
+      this.editorDocModels.delete(uri);
+      return doc;
+    }
+    this._modelsToDispose.delete(uri);
+  }
+
+  async changeModelOptions(uri: URI, options: IPreferredModelOptions) {
+    return this.onceReady(() => {
+      if (this.preferredModelOptions.has(uri.toString())) {
+        options = {
+          ...this.preferredModelOptions.get(uri.toString()),
+          ...options,
+        };
+      }
+      this.preferredModelOptions.set(uri.toString(), options);
+      const docRef = this.getModelReference(uri);
+      if (docRef) {
+        if (options.encoding && options.encoding !== docRef.instance.encoding) {
+          docRef.instance.updateEncoding(options.encoding);
+        }
+        if (options.languageId && options.languageId !== docRef.instance.languageId) {
+          docRef.instance.languageId = options.languageId;
+        }
+        if (options.eol && options.eol !== docRef.instance.eol) {
+          docRef.instance.eol = options.eol;
+        }
+        docRef.dispose();
+      }
+      return this.persistOptionsPreference();
+    });
+  }
+
+  persistOptionsPreference() {
+    return this.storage.set(EDITOR_DOC_OPTIONS_PREF_KEY, JSON.stringify(mapToSerializable(this.preferredModelOptions)));
+  }
+
+  @memoize
+  async initialize() {
+    this.storage = await this.getStorage(EDITOR_DOCUMENT_MODEL_STORAGE);
+    if (this.storage.get(EDITOR_DOC_OPTIONS_PREF_KEY)) {
+      try {
+        this.preferredModelOptions = serializableToMap(JSON.parse(this.storage.get(EDITOR_DOC_OPTIONS_PREF_KEY)!));
+      } catch (e) {
+        this.logger.error(e);
+      }
+    }
+    this._ready.ready();
+  }
+
+  @OnEvent(EditorDocumentModelOptionExternalUpdatedEvent)
+  async acceptExternalChange(e: EditorDocumentModelOptionExternalUpdatedEvent) {
+    if (!this.hashCalculateService.initialized) {
+      await this.hashCalculateService.initialize();
+    }
+    const doc = this.editorDocModels.get(e.payload.toString());
+    if (doc) {
+      if (doc.dirty) {
+        // do nothing
+      } else {
+        const provider = await this.contentRegistry.getProvider(doc.uri);
+        if (provider) {
+          if (provider.provideEditorDocumentModelContentMd5) {
+            const nextMd5 = await provider.provideEditorDocumentModelContentMd5(doc.uri, doc.encoding);
+            if (nextMd5 !== doc.getBaseContentMd5()) {
+              doc.updateContent(await this.contentRegistry.getContentForUri(doc.uri, doc.encoding), undefined, true);
+            }
+          } else {
+            const content = await this.contentRegistry.getContentForUri(doc.uri, doc.encoding);
+            if (this.hashCalculateService.calculate(content) !== doc.getBaseContentMd5()) {
+              doc.updateContent(content, undefined, true);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  createModelReference(uri: URI, reason?: string | undefined): Promise<IRef<IEditorDocumentModel>> {
+    return this._modelReferenceManager.getReference(uri.toString(), reason);
+  }
+
+  getModelReference(uri: URI, reason?: string | undefined): IRef<IEditorDocumentModel> | null {
+    return this._modelReferenceManager.getReferenceIfHasInstance(uri.toString(), reason);
+  }
+
+  getAllModels(): IEditorDocumentModel[] {
+    return Array.from(this.editorDocModels.values());
+  }
+
+  hasLanguage(langaugeId) {
+    return this.getAllModels().findIndex((m) => m.languageId === langaugeId) !== -1;
+  }
+
+  async getOrCreateModel(uri: string, encoding?: string): Promise<EditorDocumentModel> {
+    if (this.editorDocModels.has(uri)) {
+      return this.editorDocModels.get(uri)!;
+    }
+    return this.createModel(uri, encoding);
+  }
+
+  private get onceReady() {
+    this.initialize();
+    return this._ready.onceReady.bind(this._ready);
+  }
+
+  private createModel(uri: string, encoding?: string): Promise<EditorDocumentModel> {
+    // 防止异步重复调用
+    if (!this.creatingEditorModels.has(uri)) {
+      const promise = this.doCreateModel(uri, encoding).then(
+        (model) => {
+          this.creatingEditorModels.delete(uri);
+          return model;
+        },
+        (e) => {
+          this.creatingEditorModels.delete(uri);
+          throw e;
+        },
+      );
+      this.creatingEditorModels.set(uri, promise);
+    }
+    return this.creatingEditorModels.get(uri)!;
+  }
+
+  private async doCreateModel(uriString: string, encoding?: string): Promise<EditorDocumentModel> {
+    const uri = new URI(uriString);
+    const provider = await this.contentRegistry.getProvider(uri);
+
+    if (!provider) {
+      throw new Error(`No document provider found for ${uri.toString()}`);
+    }
+
+    const [content, readonly, languageId, eol, alwaysDirty, closeAutoSave, disposeEvenDirty] = await Promise.all([
+      provider.provideEditorDocumentModelContent(uri, encoding),
+      provider.isReadonly ? provider.isReadonly(uri) : undefined,
+      provider.preferLanguageForUri ? provider.preferLanguageForUri(uri) : undefined,
+      provider.provideEOL ? provider.provideEOL(uri) : undefined,
+      provider.isAlwaysDirty ? provider.isAlwaysDirty(uri) : false,
+      provider.closeAutoSave ? provider.closeAutoSave(uri) : false,
+      provider.disposeEvenDirty ? provider.disposeEvenDirty(uri) : false,
+    ] as const);
+
+    // 优先使用 preferred encoding，然后用 detected encoding
+    if (!encoding && provider.provideEncoding) {
+      encoding = await provider.provideEncoding(uri);
+    }
+
+    const savable = !!provider.saveDocumentModel;
+
+    const model = this.injector.get(EditorDocumentModel, [
+      uri,
+      content,
+      {
+        readonly,
+        languageId,
+        savable,
+        eol,
+        encoding,
+        alwaysDirty,
+        closeAutoSave,
+        disposeEvenDirty,
+      },
+    ]);
+
+    this.onceReady(() => {
+      if (this.preferredModelOptions.has(uri.toString())) {
+        const preferedOptions = this.preferredModelOptions.get(uri.toString());
+        if (preferedOptions?.encoding) {
+          model.updateEncoding(preferedOptions.encoding);
+        }
+
+        if (preferedOptions?.eol) {
+          model.eol = preferedOptions.eol;
+        }
+
+        if (preferedOptions?.languageId) {
+          model.languageId = preferedOptions.languageId;
+        }
+      }
+    });
+
+    this.editorDocModels.set(uri.toString(), model);
+    return model;
+  }
+
+  async saveEditorDocumentModel(
+    uri: URI,
+    content: string,
+    baseContent: string,
+    changes: IEditorDocumentChange[],
+    encoding?: string,
+    ignoreDiff?: boolean,
+    eol?: EOL,
+  ): Promise<IEditorDocumentModelSaveResult> {
+    const provider = await this.contentRegistry.getProvider(uri);
+
+    if (!provider) {
+      throw new Error(`No document provider found for ${uri.toString()}`);
+    }
+    if (!provider.saveDocumentModel) {
+      throw new Error(`The document provider of ${uri.toString()} does not have a save method`);
+    }
+
+    const result = await provider.saveDocumentModel(uri, content, baseContent, changes, encoding, ignoreDiff, eol);
+    return result;
+  }
+
+  dispose() {
+    super.dispose();
+    this.getAllModels().forEach((model) => {
+      model.getMonacoModel().dispose();
+    });
+  }
+}