@opensumi/ide-editor 2.21.13 → 2.22.0

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

@@ -0,0 +1,119 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, IDisposable, IEventBus, Emitter, LRUMap } from '@opensumi/ide-core-browser';
+
+import {
+  IEditorDocumentModelContentRegistry,
+  IEditorDocumentModelContentProvider,
+  EditorDocumentModelOptionExternalUpdatedEvent,
+  ORIGINAL_DOC_SCHEME,
+} from './types';
+
+@Injectable()
+export class EditorDocumentModelContentRegistryImpl implements IEditorDocumentModelContentRegistry {
+  private providers: IEditorDocumentModelContentProvider[] = [];
+
+  @Autowired(IEventBus)
+  eventBus: IEventBus;
+
+  private _onOriginalDocChanged: Emitter<URI> = new Emitter();
+
+  private originalProvider: IEditorDocumentModelContentProvider;
+
+  private cachedProviders = new LRUMap<string, Promise<IEditorDocumentModelContentProvider | undefined>>(1000, 500);
+
+  constructor() {
+    this.originalProvider = {
+      handlesScheme: (scheme: string) => scheme === ORIGINAL_DOC_SCHEME,
+      provideEditorDocumentModelContent: async (uri: URI) => {
+        const { target } = uri.getParsedQuery();
+        const targetUri = new URI(target);
+        return (await this.getContentForUri(targetUri)) || '';
+      },
+      isReadonly: () => true,
+      onDidChangeContent: this._onOriginalDocChanged.event,
+    };
+    this.registerEditorDocumentModelContentProvider(this.originalProvider);
+  }
+
+  registerEditorDocumentModelContentProvider(provider: IEditorDocumentModelContentProvider): IDisposable {
+    this.providers.push(provider);
+    this.cachedProviders.clear();
+    const disposer = provider.onDidChangeContent((uri) => {
+      this.eventBus.fire(new EditorDocumentModelOptionExternalUpdatedEvent(uri));
+    });
+    // 每次注册 doc content provider， 都同时注册一个用于取出原始文档内容的doc provider
+    // 处理的doc uri为shadowed_前缀的scheme
+    if (provider !== this.originalProvider && provider.onDidChangeContent) {
+      provider.onDidChangeContent((uri) => {
+        this._onOriginalDocChanged.fire(
+          URI.from({
+            scheme: ORIGINAL_DOC_SCHEME,
+            query: URI.stringifyQuery({
+              target: uri.toString(),
+            }),
+          }),
+        );
+      });
+    }
+
+    return {
+      dispose: () => {
+        disposer.dispose();
+        const index = this.providers.indexOf(provider);
+        if (index) {
+          this.providers.splice(index, 1);
+          this.cachedProviders.clear();
+        }
+      },
+    };
+  }
+
+  getProvider(uri: URI): Promise<IEditorDocumentModelContentProvider | undefined> {
+    const uriStr = uri.toString();
+    if (!this.cachedProviders.has(uriStr)) {
+      this.cachedProviders.set(uriStr, this.calculateProvider(uri));
+    }
+    return this.cachedProviders.get(uriStr)!;
+  }
+
+  // Ant Codespaces 需要使用该方法复写 getProvider，不使用缓存 provider
+  protected async calculateProvider(uri: URI): Promise<IEditorDocumentModelContentProvider | undefined> {
+    let calculated: {
+      provider: IEditorDocumentModelContentProvider | undefined;
+      weight: number;
+      index: number;
+    } = {
+      provider: undefined,
+      weight: -1,
+      index: 1,
+    };
+    for (const provider of this.providers) {
+      let weight = -1;
+      const index = this.providers.indexOf(provider);
+      if (provider.handlesUri) {
+        weight = await provider.handlesUri(uri);
+      } else if (provider.handlesScheme) {
+        weight = (await provider.handlesScheme(uri.scheme)) ? 10 : -1;
+      }
+
+      if (weight >= 0) {
+        if (weight > calculated.weight || (weight === calculated.weight && index > calculated.index)) {
+          calculated = {
+            index,
+            weight,
+            provider,
+          };
+        }
+      }
+    }
+    return calculated.provider;
+  }
+
+  async getContentForUri(uri: URI, encoding?: string): Promise<string> {
+    const p = await this.getProvider(uri);
+    if (!p) {
+      throw new Error();
+    }
+    return p.provideEditorDocumentModelContent(uri, encoding);
+  }
+}

package/src/browser/doc-model/editor-is-fn.ts

@@ -0,0 +1,9 @@
+import { IStackElement, IEditStackElement, IEOLStackElement } from './types';
+
+export function isEditStack(element: IStackElement): element is IEditStackElement {
+  return !!(element as IEditStackElement).editOperations;
+}
+
+export function isEOLStack(element: IStackElement): element is IEOLStackElement {
+  return !!(element as IEOLStackElement).eol;
+}

package/src/browser/doc-model/main.ts

@@ -0,0 +1,4 @@
+export * from './editor-document-model-service';
+export * from './editor-document-model';
+export * from './editor-document-registry';
+export * from './save-task';

package/src/browser/doc-model/override.ts

@@ -0,0 +1,49 @@
+/* istanbul ignore file */
+import { Autowired, Injectable } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-browser';
+import {
+  ITextModelService,
+  ITextModelContentProvider,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/common/services/resolverService';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import { IEditorDocumentModelService } from './types';
+
+@Injectable()
+export class MonacoTextModelService implements ITextModelService {
+  canHandleResource(resource: any): boolean {
+    return true;
+  }
+
+  hasTextModelContentProvider(scheme: string): boolean {
+    throw new Error('Method not implemented.');
+  }
+
+  _serviceBrand: undefined;
+
+  @Autowired(IEditorDocumentModelService)
+  documentModelManager: IEditorDocumentModelService;
+
+  async createModelReference(resource: monaco.Uri) {
+    const docModelRef = await this.documentModelManager.createModelReference(new URI(resource.toString()), 'monaco');
+    if (docModelRef) {
+      const model = docModelRef.instance.getMonacoModel();
+      return Promise.resolve({
+        object: {
+          textEditorModel: model,
+        },
+        dispose: () => {
+          docModelRef.dispose();
+        },
+      }) as any;
+    }
+  }
+
+  registerTextModelContentProvider(scheme: string, provider: ITextModelContentProvider): monaco.IDisposable {
+    return {
+      dispose(): void {
+        // no-op
+      },
+    };
+  }
+}

package/src/browser/doc-model/save-task.ts

@@ -0,0 +1,88 @@
+import {
+  URI,
+  Deferred,
+  IEditorDocumentChange,
+  IEditorDocumentModelSaveResult,
+  CancellationTokenSource,
+  Disposable,
+  CancellationToken,
+  SaveTaskResponseState,
+  SaveTaskErrorCause,
+} from '@opensumi/ide-core-browser';
+import { EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+
+import { IEditorDocumentModelService } from './types';
+
+export interface IEditorDocumentModelServiceImpl extends IEditorDocumentModelService {
+  saveEditorDocumentModel(
+    uri: URI,
+    content: string,
+    baseContent: string,
+    changes: IEditorDocumentChange[],
+    encoding?: string,
+    ignoreDiff?: boolean,
+    eol?: EOL,
+    token?: CancellationToken,
+  ): Promise<IEditorDocumentModelSaveResult>;
+}
+
+export class SaveTask extends Disposable {
+  private deferred: Deferred<IEditorDocumentModelSaveResult> = new Deferred();
+
+  public finished: Promise<IEditorDocumentModelSaveResult> = this.deferred.promise;
+
+  private cancelToken: CancellationTokenSource;
+
+  public started = false;
+
+  constructor(
+    private uri: URI,
+    public readonly versionId: number,
+    public readonly alternativeVersionId: number,
+    public content: string,
+    private ignoreDiff: boolean,
+  ) {
+    super();
+    this.disposables.push((this.cancelToken = new CancellationTokenSource()));
+  }
+
+  async run(
+    service: IEditorDocumentModelServiceImpl,
+    baseContent: string,
+    changes: IEditorDocumentChange[],
+    encoding?: string,
+    eol?: EOL,
+  ): Promise<IEditorDocumentModelSaveResult> {
+    this.started = true;
+    try {
+      const res = await service.saveEditorDocumentModel(
+        this.uri,
+        this.content,
+        baseContent,
+        changes,
+        encoding,
+        this.ignoreDiff,
+        eol,
+        this.cancelToken.token,
+      );
+      this.deferred.resolve(res);
+      return res;
+    } catch (e) {
+      const res: IEditorDocumentModelSaveResult = {
+        errorMessage: e.message,
+        state: SaveTaskResponseState.ERROR,
+      };
+      this.deferred.resolve(res);
+      return res;
+    }
+  }
+
+  cancel() {
+    this.cancelToken.cancel();
+    const res: IEditorDocumentModelSaveResult = {
+      errorMessage: SaveTaskErrorCause.CANCEL,
+      state: SaveTaskResponseState.ERROR,
+    };
+    this.deferred.resolve(res);
+  }
+}

package/src/browser/doc-model/saveParticipants.ts

@@ -0,0 +1,227 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import {
+  ClientAppContribution,
+  WithEventBus,
+  Domain,
+  OnEvent,
+  PreferenceService,
+  CommandService,
+  ServiceNames,
+  ILogger,
+  MonacoOverrideServiceRegistry,
+  IProgress,
+  ProgressLocation,
+  IProgressStep,
+  formatLocalize,
+} from '@opensumi/ide-core-browser';
+import { IProgressService } from '@opensumi/ide-core-browser/lib/progress';
+import { ResourceEdit } from '@opensumi/ide-monaco/lib/browser/monaco-api';
+import { languageFeaturesService } from '@opensumi/ide-monaco/lib/browser/monaco-api/languages';
+import { ITextModel } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+import * as languages from '@opensumi/monaco-editor-core/esm/vs/editor/common/languages';
+import { CodeActionProvider } from '@opensumi/monaco-editor-core/esm/vs/editor/common/languages';
+import {
+  getCodeActions,
+  CodeActionItem,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/codeAction/browser/codeAction';
+import {
+  CodeActionKind,
+  CodeActionTriggerSource,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/contrib/codeAction/browser/types';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import { SaveReason } from '../types';
+
+import { EditorDocumentModelWillSaveEvent, IEditorDocumentModelService } from './types';
+
+@Injectable()
+export class CodeActionOnSaveParticipant extends WithEventBus {
+  @Autowired(PreferenceService)
+  private readonly preferenceService: PreferenceService;
+
+  @Autowired(MonacoOverrideServiceRegistry)
+  private readonly overrideServiceRegistry: MonacoOverrideServiceRegistry;
+
+  @Autowired(CommandService)
+  private readonly commandService: CommandService;
+
+  @Autowired(IEditorDocumentModelService)
+  private readonly docService: IEditorDocumentModelService;
+
+  @Autowired(ILogger)
+  private readonly logger: ILogger;
+
+  @Autowired(IProgressService)
+  private readonly progressService: IProgressService;
+
+  get bulkEditService(): any {
+    return this.overrideServiceRegistry.getRegisteredService(ServiceNames.BULK_EDIT_SERVICE);
+  }
+
+  activate() {
+    // noop
+  }
+
+  @OnEvent(EditorDocumentModelWillSaveEvent)
+  async onEditorDocumentModelWillSave(e: EditorDocumentModelWillSaveEvent) {
+    // 自动保存不运行
+    if (e.payload.reason !== SaveReason.Manual) {
+      return;
+    }
+
+    const preferenceActions = this.preferenceService.get<
+      | {
+          [prop: string]: any;
+        }
+      | string[]
+    >('editor.codeActionsOnSave', undefined, e.payload.uri.toString(), e.payload.language);
+    if (!preferenceActions) {
+      return undefined;
+    }
+
+    return this.progressService.withProgress(
+      {
+        title: formatLocalize('editor.saveCodeActions.saving', e.payload.uri.displayName),
+        location: ProgressLocation.Notification,
+        cancellable: true,
+      },
+      async (progress) => {
+        const codeActions = Array.isArray(preferenceActions) ? preferenceActions : Object.keys(preferenceActions);
+        const codeActionsOnSave: CodeActionKind[] = codeActions.map((p) => new CodeActionKind(p));
+
+        if (!Array.isArray(preferenceActions)) {
+          codeActionsOnSave.sort((a, b) => {
+            if (CodeActionKind.SourceFixAll.contains(a)) {
+              if (CodeActionKind.SourceFixAll.contains(b)) {
+                return 0;
+              }
+              return -1;
+            }
+            if (CodeActionKind.SourceFixAll.contains(b)) {
+              return 1;
+            }
+            return 0;
+          });
+        }
+        if (codeActionsOnSave.length === 0) {
+          return;
+        }
+
+        const modelRef = this.docService.getModelReference(e.payload.uri, 'codeActionOnSave');
+        if (!modelRef) {
+          return;
+        }
+
+        const model = modelRef.instance.getMonacoModel();
+
+        const tokenSource = new monaco.CancellationTokenSource();
+
+        const timeout = this.preferenceService.get<number>(
+          'editor.codeActionsOnSaveTimeout',
+          undefined,
+          e.payload.uri.toString(),
+          e.payload.language,
+        );
+
+        const excludedActions = Array.isArray(preferenceActions)
+          ? []
+          : Object.keys(preferenceActions)
+              .filter((x: string) => preferenceActions[x] === false)
+              .map((x: string) => new CodeActionKind(x));
+
+        return Promise.race([
+          new Promise<void>((_resolve, reject) =>
+            setTimeout(() => {
+              tokenSource.cancel();
+              reject('codeActionsOnSave timeout');
+            }, timeout),
+          ),
+          this.applyOnSaveActions(model, codeActionsOnSave, excludedActions, progress, tokenSource.token),
+        ]).finally(() => {
+          tokenSource.cancel();
+          modelRef.dispose();
+        });
+      },
+    );
+  }
+
+  private async applyOnSaveActions(
+    model: ITextModel,
+    actions: CodeActionKind[],
+    excludes: readonly CodeActionKind[],
+    progress: IProgress<IProgressStep>,
+    token: monaco.CancellationToken,
+  ) {
+    const getActionProgress = new (class implements IProgress<CodeActionProvider> {
+      private _names = new Set<string>();
+      private _report(): void {
+        progress.report({
+          message: formatLocalize(
+            'editor.saveCodeActions.getting',
+            [...this._names].map((name) => `'${name}'`).join(', '),
+          ),
+        });
+      }
+      report(provider: CodeActionProvider) {
+        if (provider.displayName && !this._names.has(provider.displayName)) {
+          this._names.add(provider.displayName);
+          this._report();
+        }
+      }
+    })();
+    for (const codeActionKind of actions) {
+      try {
+        const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, getActionProgress, token);
+
+        await this.applyCodeActions(actionsToRun.validActions);
+      } catch (e) {
+        this.logger.error(e);
+      }
+    }
+  }
+
+  private async applyCodeActions(actionsToRun: readonly CodeActionItem[]) {
+    for (const actionItem of actionsToRun) {
+      if (actionItem.action.edit) {
+        await this.bulkEditService?.apply(ResourceEdit.convert(actionItem.action.edit));
+      }
+      if (actionItem.action.command) {
+        await this.commandService.executeCommand(
+          actionItem.action.command.id,
+          ...(actionItem.action.command.arguments || []),
+        );
+      }
+    }
+  }
+
+  private async getActionsToRun(
+    model: ITextModel,
+    codeActionKind: CodeActionKind,
+    excludes: readonly CodeActionKind[],
+    progress: IProgress<CodeActionProvider>,
+    token: monaco.CancellationToken,
+  ) {
+    return getCodeActions(
+      languageFeaturesService.codeActionProvider,
+      model,
+      model.getFullModelRange(),
+      {
+        type: languages.CodeActionTriggerType.Auto,
+        filter: { include: codeActionKind, excludes, includeSourceActions: true },
+        triggerAction: CodeActionTriggerSource.OnSave,
+      },
+      progress,
+      token,
+    );
+  }
+}
+
+@Domain(ClientAppContribution)
+export class SaveParticipantsContribution implements ClientAppContribution {
+  @Autowired()
+  codeActionOnSaveParticipant: CodeActionOnSaveParticipant;
+
+  onStart() {
+    this.codeActionOnSaveParticipant.activate();
+  }
+}