@opensumi/ide-editor 3.8.3-next-1745907010.0 → 3.8.3-next-1746586819.0

package/src/browser/types.ts

@@ -27,6 +27,7 @@ import {
   ResourceService,
   TrackedRangeStickiness,
 } from '../common';
+import { IMultiDiffSourceResolverService } from '../common/multi-diff';
 
 import { IEditorDocumentModelContentRegistry } from './doc-model/types';
 import { EditorGroup } from './workbench-editor.service';
@@ -188,6 +189,12 @@ export interface BrowserEditorContribution {
   registerEditorFeature?(registry: IEditorFeatureRegistry);
 }
 
+export const MultiDiffSourceContribution = Symbol('MultiDiffSourceContribution');
+
+export interface MultiDiffSourceContribution {
+  registerMultiDiffSourceResolver(resolverService: IMultiDiffSourceResolverService): IDisposable;
+}
+
 export interface IGridResizeEventPayload {
   gridId: string;
 }

package/src/browser/workbench-editor.service.ts

@@ -53,6 +53,7 @@ import {
 import { IFileServiceClient } from '@opensumi/ide-file-service';
 import * as monaco from '@opensumi/ide-monaco';
 import { IDialogService, IMessageService, IWindowDialogService } from '@opensumi/ide-overlay';
+import { Dimension } from '@opensumi/monaco-editor-core/esm/vs/base/browser/dom';
 
 import {
   CursorStatus,
@@ -76,6 +77,7 @@ import {
   getSplitActionFromDragDrop,
 } from '../common';
 import { IEditorDocumentModelRef } from '../common/editor';
+import { IMultiDiffEditor } from '../common/multi-diff';
 
 import { EditorDocumentModel } from './doc-model/editor-document-model';
 import { IEditorDocumentModelService } from './doc-model/types';
@@ -730,6 +732,8 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
 
   diffEditor!: IDiffEditor;
 
+  multiDiffEditor!: IMultiDiffEditor;
+
   mergeEditor!: IMergeEditorEditor;
 
   private openingPromise: Map<string, Promise<IOpenResourceResult>> = new Map();
@@ -824,6 +828,8 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
   private _domNode: MaybeNull<HTMLElement> = null;
   private _diffEditorDomNode: MaybeNull<HTMLElement> = null;
   private _diffEditorDomNodeAttached = false;
+  private _multiFileDiffEditorDomNode: MaybeNull<HTMLElement> = null;
+  private _multiFileDiffEditorDomNodeAttached = false;
   private _mergeEditorDomNode: MaybeNull<HTMLElement> = null;
   private _mergeEditorDomNodeAttached = false;
 
@@ -832,6 +838,8 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
   private diffEditorReady = new ReadyEvent();
   private diffEditorDomReady = new ReadyEvent();
 
+  private multiDiffEditorDomReady = new ReadyEvent();
+
   private mergeEditorReady = new ReadyEvent();
   private mergeEditorDomReady = new ReadyEvent();
 
@@ -841,6 +849,9 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
 
   private _currentOrPreviousFocusedEditor: IEditor | null;
 
+  private _multiDiffEditorDomNode: HTMLElement | null | undefined;
+  private _multiDiffEditorDomNodeAttached = false;
+
   constructor(public readonly name: string, public readonly groupId: number) {
     super();
     this.eventBus.onDirective(
@@ -928,6 +939,13 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
           this.diffEditor.layout();
         }
         break;
+      case EditorOpenType.multiDiff:
+        if (this.multiDiffEditor && this._multiDiffEditorDomNodeAttached) {
+          this.multiDiffEditor.layout(
+            new Dimension(this._multiDiffEditorDomNode!.offsetWidth, this._multiDiffEditorDomNode!.offsetHeight),
+          );
+        }
+        break;
       default:
         break;
     }
@@ -1865,6 +1883,9 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
         case EditorOpenType.diff:
           await this.openDiffEditor(resource, options);
           break;
+        case EditorOpenType.multiDiff:
+          await this.openMultiDiffEditor(resource, options);
+          break;
         case EditorOpenType.mergeEditor:
           await this.openMergeEditor(resource);
           break;
@@ -2277,6 +2298,7 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
     super.dispose();
     this.codeEditor && this.codeEditor.dispose();
     this.diffEditor && this.diffEditor.dispose();
+    this.multiDiffEditor && this.multiDiffEditor.dispose();
     this.toDispose.forEach((disposable) => disposable.dispose());
     this.eventBus.fire(
       new EditorGroupDisposeEvent({
@@ -2441,6 +2463,35 @@ export class EditorGroup extends WithEventBus implements IGridEditorGroup {
       name: this.name,
     };
   }
+
+  attachMultiDiffEditorDom(domNode: HTMLElement | null | undefined) {
+    if (!this._multiDiffEditorDomNodeAttached) {
+      this._multiDiffEditorDomNode = domNode;
+      this.multiDiffEditorDomReady.ready();
+      this._multiDiffEditorDomNodeAttached = true;
+    }
+  }
+
+  createMultiDiffEditor(dom: HTMLElement) {
+    const editor = this.collectionService.createMultiDiffEditor(
+      dom,
+      {},
+      { [ServiceNames.CONTEXT_KEY_SERVICE]: this.contextKeyService.contextKeyService },
+    );
+    this.multiDiffEditor = editor;
+  }
+
+  private async openMultiDiffEditor(resource: IResource, options: IResourceOpenOptions) {
+    if (!this.multiDiffEditor) {
+      await this.multiDiffEditorDomReady.onceReady(() => {
+        const container = document.createElement('div');
+        this._multiDiffEditorDomNode?.appendChild(container);
+        this.createMultiDiffEditor(container);
+      });
+    }
+
+    await this.multiDiffEditor.compareMultiple(resource, options);
+  }
 }
 
 function findSuitableOpenType(

package/src/common/editor.ts

@@ -16,6 +16,7 @@ import {
   URI,
 } from '@opensumi/ide-core-common';
 
+import { IMultiDiffEditor } from './multi-diff';
 import { IResource } from './resource';
 import { IDocModelUpdateOptions } from './types';
 
@@ -344,6 +345,18 @@ export abstract class EditorCollectionService {
    */
   public abstract createDiffEditor(dom: HTMLElement, options?: any, overrides?: { [key: string]: any }): IDiffEditor;
 
+  /**
+   * 创建一个 monaco multiFileDiffEditor 实例
+   * @param dom
+   * @param options
+   * @param overrides
+   */
+  public abstract createMultiDiffEditor(
+    dom: HTMLElement,
+    options?: any,
+    overrides?: { [key: string]: any },
+  ): IMultiDiffEditor;
+
   public abstract createMergeEditor(
     dom: HTMLElement,
     options?: any,
@@ -869,6 +882,7 @@ export enum EditorOpenType {
   diff = 'diff',
   mergeEditor = 'mergeEditor',
   component = 'component',
+  multiDiff = 'multiDiff',
 }
 
 // 定义一个resource如何被打开

package/src/common/multi-diff.ts

@@ -0,0 +1,87 @@
+import { Event, IDisposable, URI } from '@opensumi/ide-core-common';
+import { ContextKeyValue } from '@opensumi/ide-monaco';
+import { Dimension } from '@opensumi/monaco-editor-core/esm/vs/base/browser/dom';
+import { IValueWithChangeEvent } from '@opensumi/monaco-editor-core/esm/vs/base/common/event';
+import {
+  IDocumentDiffItem,
+  IMultiDiffEditorModel,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/browser/widget/multiDiffEditor/model';
+
+import { IResourceOpenOptions } from './editor';
+import { IResource } from './resource';
+
+export const MULTI_DIFF_SCHEME = 'multi-diff-editor';
+
+export const IMultiDiffSourceResolverService = Symbol('IMultiDiffSourceResolverService');
+
+export interface IMultiDiffSourceResolverService {
+  registerResolver(resolver: IMultiDiffSourceResolver): IDisposable;
+
+  resolve(uri: URI): Promise<IResolvedMultiDiffSource | undefined>;
+
+  getResolvers(): IMultiDiffSourceResolver[];
+}
+
+export interface IMultiDiffSourceResolver {
+  canHandleUri(uri: URI): boolean;
+
+  resolveDiffSource(uri: URI): Promise<IResolvedMultiDiffSource | undefined>;
+}
+
+export interface IResolvedMultiDiffSource {
+  readonly resources: IValueWithChangeEvent<readonly MultiDiffEditorItem[]>;
+  readonly contextKeys?: Record<string, ContextKeyValue>;
+}
+
+export class MultiDiffEditorItem {
+  constructor(
+    readonly originalUri: URI | undefined,
+    readonly modifiedUri: URI | undefined,
+    readonly goToFileUri: URI | undefined,
+    readonly contextKeys?: Record<string, ContextKeyValue>,
+  ) {
+    if (!originalUri && !modifiedUri) {
+      throw new Error('Invalid arguments');
+    }
+  }
+
+  getKey(): string {
+    return JSON.stringify([this.modifiedUri?.toString(), this.originalUri?.toString()]);
+  }
+}
+
+/**
+ * Multi-file Diff Editor abstraction
+ * Extends the concept of diff editor to handle multiple file pairs
+ */
+export interface IMultiDiffEditor extends IDisposable {
+  /**
+   * Compare multiple file pairs
+   */
+  compareMultiple(resource: IResource, options?: IResourceOpenOptions): Promise<void>;
+
+  /**
+   * Get all file pairs currently being compared
+   */
+  getDiffEntry(uri: URI): IDocumentDiffItem | undefined;
+
+  /**
+   * Get the currently selected/active file pair
+   */
+  getCurrentDiffEntry(): IDocumentDiffItem | undefined;
+
+  /**
+   * Layout the editor
+   */
+  layout(dimension: Dimension): void;
+
+  /**
+   * Focus the editor
+   */
+  focus(): void;
+
+  /**
+   * Event emitted when the multi-diff editor model changes
+   */
+  onMultiDiffModelChange: Event<IMultiDiffEditorModel>;
+}