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

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

@@ -27,6 +27,7 @@ import {
   IDecorationApplyOptions,
   IDiffEditor,
   IEditor,
+  IResource,
   IResourceOpenOptions,
   IUndoStopOptions,
   ResourceDecorationNeedChangeEvent,
@@ -36,8 +37,9 @@ import { IEditorDocumentModel, IEditorDocumentModelRef, isTextEditorViewState }
 import { MonacoEditorDecorationApplier } from './decoration-applier';
 import { EditorDocumentModelContentChangedEvent, IEditorDocumentModelService } from './doc-model/types';
 import { EditorFeatureRegistryImpl } from './feature';
+import { BrowserMultiDiffEditor } from './multi-diff/multi-diff-editor';
 import { getConvertedMonacoOptions, isDiffEditorOption, isEditorOption } from './preference/converter';
-import { IEditorFeatureRegistry } from './types';
+import { IConvertedMonacoOptions, IEditorFeatureRegistry } from './types';
 
 import type {
   ICodeEditor as IMonacoCodeEditor,
@@ -152,6 +154,14 @@ export class EditorCollectionServiceImpl extends WithEventBus implements EditorC
     return editor;
   }
 
+  createMultiDiffEditor(dom: HTMLElement, options?: any, overrides?: { [key: string]: any }) {
+    const convertedOptions = getConvertedMonacoOptions(this.configurationService);
+    const monacoMultiDiffEditorWidget = this.monacoService.createMultiDiffEditorWidget(dom, overrides);
+    const mergedOptions: IConvertedMonacoOptions = { ...convertedOptions.diffOptions, ...options };
+    const editor = this.injector.get(BrowserMultiDiffEditor, [monacoMultiDiffEditorWidget, mergedOptions]);
+    return editor;
+  }
+
   public createMergeEditor(dom: HTMLElement, options?: any, overrides?: { [key: string]: any }) {
     const convertedOptions = getConvertedMonacoOptions(this.configurationService);
     const mergedOptions: IDiffEditorConstructionOptions = {

package/src/browser/editor.contribution.ts

@@ -44,7 +44,7 @@ import { IMenuRegistry, MenuContribution, MenuId } from '@opensumi/ide-core-brow
 import { AbstractContextMenuService } from '@opensumi/ide-core-browser/lib/menu/next/menu.interface';
 import { ICtxMenuRenderer } from '@opensumi/ide-core-browser/lib/menu/next/renderer/ctxmenu/base';
 import { IRelaxedOpenMergeEditorArgs } from '@opensumi/ide-core-browser/lib/monaco/merge-editor-widget';
-import { IDisposable, ILogger, PreferenceScope, isWindows } from '@opensumi/ide-core-common';
+import { IDisposable, ILogger, PreferenceScope, UriComponents, isWindows } from '@opensumi/ide-core-common';
 import { MergeEditorService } from '@opensumi/ide-monaco/lib/browser/contrib/merge-editor/merge-editor.service';
 import { ITextmateTokenizer, ITextmateTokenizerService } from '@opensumi/ide-monaco/lib/browser/contrib/tokenizer';
 import { EOL } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
@@ -68,6 +68,7 @@ import {
   WorkbenchEditorService,
 } from '../common';
 import { AUTO_SAVE_MODE } from '../common/editor';
+import { MultiDiffEditorItem } from '../common/multi-diff';
 
 import { MonacoTextModelService } from './doc-model/override';
 import { IEditorDocumentModelContentRegistry, IEditorDocumentModelService } from './doc-model/types';
@@ -79,6 +80,7 @@ import { DocumentFormatService } from './format/format.service';
 import { FormattingSelector } from './format/formatter-selector';
 import { EditorHistoryService } from './history';
 import { EditorContextMenuController } from './menu/editor.context';
+import { MultiDiffResolver } from './multi-diff/multi-diff-resolver';
 import { NavigationMenuContainer } from './navigation.view';
 import { GoToLineQuickOpenHandler } from './quick-open/go-to-line';
 import { WorkspaceSymbolQuickOpenHandler } from './quick-open/workspace-symbol-quickopen';
@@ -231,6 +233,9 @@ export class EditorContribution
   @Autowired(ICtxMenuRenderer)
   private readonly contextMenuRenderer: ICtxMenuRenderer;
 
+  @Autowired(MultiDiffResolver)
+  private readonly multiDiffResolver: MultiDiffResolver;
+
   registerMonacoDefaultFormattingSelector(register: (selector: IFormattingEditProviderSelector) => IDisposable): void {
     const formatSelector = this.injector.get(FormattingSelector);
     this.addDispose(register(formatSelector.selectFormatter.bind(formatSelector)));
@@ -1231,6 +1236,36 @@ export class EditorContribution
         formatService.formatSelectionWith();
       },
     });
+
+    commands.registerCommand(
+      {
+        id: EDITOR_COMMANDS.VSCODE_OPEN_MULTI_DIFF_EDITOR_COMMAND_ID,
+      },
+      {
+        execute: async (options: {
+          title: string;
+          multiDiffSourceUri: UriComponents;
+          resources: { originalUri?: UriComponents; modifiedUri?: UriComponents }[];
+        }) => {
+          const sources: MultiDiffEditorItem[] = [];
+          for (const { originalUri, modifiedUri } of options.resources) {
+            sources.push(
+              new MultiDiffEditorItem(
+                originalUri ? URI.from(originalUri) : undefined,
+                modifiedUri ? URI.from(modifiedUri) : undefined,
+                modifiedUri ? URI.from(modifiedUri) : undefined,
+              ),
+            );
+          }
+          const multiDiffSourceUri = URI.from(options.multiDiffSourceUri);
+          // 提前注册到 resolver 内，相同的multiDiffSourceUri支持更新
+          this.multiDiffResolver.registerSources(multiDiffSourceUri, sources);
+          await this.workbenchEditorService.open(multiDiffSourceUri, {
+            label: options.title,
+          });
+        },
+      },
+    );
   }
 
   registerMenus(menus: IMenuRegistry) {

package/src/browser/editor.module.less

@@ -6,6 +6,12 @@
   background-color: var(--editor-background);
   display: flex;
   border-top: 1px solid var(--tab-border);
+
+  .kt_editor_multi_diff_editor {
+    height: 100%;
+    width: 100%;
+    position: relative;
+  }
 }
 .kt_editor_main_wrapper {
   flex-grow: 1;

package/src/browser/editor.view.tsx

@@ -316,6 +316,7 @@ export const EditorGroupBody = ({ group }: { group: EditorGroup }) => {
   const components: React.ReactNode[] = [];
   const codeEditorRef = React.useRef<HTMLDivElement>(null);
   const diffEditorRef = React.useRef<HTMLDivElement>(null);
+  const multiDiffEditorRef = React.useRef<HTMLDivElement>(null);
   const mergeEditorRef = React.useRef<HTMLDivElement>(null);
   const [, updateState] = React.useState<any>();
   const forceUpdate = React.useCallback(() => updateState({}), []);
@@ -367,6 +368,21 @@ export const EditorGroupBody = ({ group }: { group: EditorGroup }) => {
     };
   }, []);
 
+  React.useEffect(() => {
+    if (multiDiffEditorRef.current) {
+      group.attachMultiDiffEditorDom(multiDiffEditorRef.current);
+      const observer = new ResizeObserver((entries) => {
+        const entry = entries[0];
+        if (entry && entry.contentRect.height > 0) {
+          group.doLayoutEditors();
+          observer.disconnect();
+        }
+      });
+      observer.observe(multiDiffEditorRef.current);
+      return () => observer.disconnect();
+    }
+  }, [multiDiffEditorRef.current]);
+
   group.activeComponents.forEach((resources, component) => {
     const initialProps = group.activateComponentsProps.get(component);
     components.push(
@@ -478,6 +494,12 @@ export const EditorGroupBody = ({ group }: { group: EditorGroup }) => {
             })}
             ref={diffEditorRef}
           />
+          <div
+            className={cls(styles.kt_editor_multi_diff_editor, styles_kt_editor_component, {
+              [styles.kt_hidden]: !group.currentOpenType || group.currentOpenType.type !== EditorOpenType.multiDiff,
+            })}
+            ref={multiDiffEditorRef}
+          />
           <div
             className={cls(styles.kt_editor_diff_3_editor, styles_kt_editor_component, {
               [styles.kt_hidden]: !group.currentOpenType || group.currentOpenType.type !== EditorOpenType.mergeEditor,

package/src/browser/index.ts

@@ -18,6 +18,7 @@ import { ITypeHierarchyService } from '@opensumi/ide-monaco/lib/browser/contrib/
 
 import { EditorCollectionService, ILanguageService, ResourceService, WorkbenchEditorService } from '../common';
 import { IDocPersistentCacheProvider } from '../common/doc-cache';
+import { IMultiDiffSourceResolverService } from '../common/multi-diff';
 
 import { BreadCrumbServiceImpl } from './breadcrumb';
 import { EditorComponentRegistryImpl } from './component';
@@ -52,6 +53,8 @@ import {
   MonacoCommandService,
 } from './monaco-contrib/command/command.service';
 import { TextmateService } from './monaco-contrib/tokenizer/textmate.service';
+import { MultiDiffEditorContribution } from './multi-diff/multi-diff.contribution';
+import { MultiDiffSourceResolverService } from './multi-diff/resolver.service';
 import { NotebookService } from './notebook.service';
 import { EditorPreferenceContribution } from './preference/contribution';
 import { EditorPreferences, editorPreferenceSchema } from './preference/schema';
@@ -67,6 +70,7 @@ import {
   IEditorTabService,
   ILanguageStatusService,
   INotebookService,
+  MultiDiffSourceContribution,
 } from './types';
 import { UntitledDocumentIdCounter } from './untitled-resource';
 import { WorkbenchEditorServiceImpl } from './workbench-editor.service';
@@ -180,8 +184,13 @@ export class EditorModule extends BrowserModule {
       token: INotebookService,
       useClass: NotebookService,
     },
+    {
+      token: IMultiDiffSourceResolverService,
+      useClass: MultiDiffSourceResolverService,
+    },
     EditorPreferenceContribution,
     DefaultDiffEditorContribution,
+    MultiDiffEditorContribution,
     MergeEditorContribution,
     EditorClientAppContribution,
     EditorContribution,
@@ -195,7 +204,7 @@ export class EditorModule extends BrowserModule {
     OpenTypeMenuContribution,
   ];
   electronProviders = [EditorElectronContribution];
-  contributionProvider = BrowserEditorContribution;
+  contributionProvider = [BrowserEditorContribution, MultiDiffSourceContribution];
 }
 
 @Domain(ClientAppContribution)
@@ -224,9 +233,15 @@ export class EditorClientAppContribution implements ClientAppContribution {
   @Autowired(IEditorDocumentModelService)
   modelService: EditorDocumentModelServiceImpl;
 
+  @Autowired(IMultiDiffSourceResolverService)
+  multiDiffSourceResolverService: IMultiDiffSourceResolverService;
+
   @Autowired(BrowserEditorContribution)
   private readonly contributions: ContributionProvider<BrowserEditorContribution>;
 
+  @Autowired(MultiDiffSourceContribution)
+  private readonly multiDiffSourceContribution: ContributionProvider<MultiDiffSourceContribution>;
+
   async initialize() {
     for (const contribution of this.contributions.getContributions()) {
       if (contribution.registerResource) {
@@ -245,6 +260,9 @@ export class EditorClientAppContribution implements ClientAppContribution {
         contribution.registerEditorFeature(this.editorFeatureRegistry);
       }
     }
+    for (const contribution of this.multiDiffSourceContribution.getContributions()) {
+      contribution.registerMultiDiffSourceResolver(this.multiDiffSourceResolverService);
+    }
     this.workbenchEditorService.contributionsReady.resolve();
     await Promise.all([this.workbenchEditorService.initialize(), this.modelService.initialize()]);
   }

package/src/browser/multi-diff/multi-diff-editor.ts

@@ -0,0 +1,249 @@
+import { Autowired, INJECTOR_TOKEN, Injectable, Injector } from '@opensumi/di';
+import { PreferenceService } from '@opensumi/ide-core-browser';
+import {
+  Disposable,
+  DisposableStore,
+  Emitter,
+  IDisposable,
+  OnEvent,
+  URI,
+  WithEventBus,
+} from '@opensumi/ide-core-common';
+import {
+  ValueWithChangeEventFromObservable,
+  constObservable,
+  derived,
+  mapObservableArrayCached,
+  observableFromValueWithChangeEvent,
+  observableValue,
+  recomputeInitiallyAndOnChange,
+} from '@opensumi/ide-monaco/lib/common/observable';
+import { IMessageService } from '@opensumi/ide-overlay';
+import { Dimension } from '@opensumi/monaco-editor-core/esm/vs/base/browser/dom';
+import { ValueWithChangeEvent } from '@opensumi/monaco-editor-core/esm/vs/base/common/event';
+import { ICodeEditor } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import { RefCounted } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/widget/diffEditor/utils';
+import {
+  IDocumentDiffItem,
+  IMultiDiffEditorModel,
+} from '@opensumi/monaco-editor-core/esm/vs/editor/browser/widget/multiDiffEditor/model';
+import { MultiDiffEditorWidget } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget';
+import { IMultiDiffResourceId } from '@opensumi/monaco-editor-core/esm/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidgetImpl';
+import { Range } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
+import { IDiffEditor } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';
+
+import { IEditorDocumentModelRef, IResourceOpenOptions } from '../../common/editor';
+import { IMultiDiffEditor, IMultiDiffSourceResolverService, IResolvedMultiDiffSource } from '../../common/multi-diff';
+import { EditorDocumentModelContentChangedEvent, IEditorDocumentModelService } from '../doc-model/types';
+import { IConvertedMonacoOptions, IResource, ResourceDecorationNeedChangeEvent } from '../types';
+
+@Injectable({ multiple: true })
+export class BrowserMultiDiffEditor extends WithEventBus implements IMultiDiffEditor {
+  @Autowired(INJECTOR_TOKEN)
+  protected readonly injector: Injector;
+
+  @Autowired(IMessageService)
+  private readonly messageService: IMessageService;
+
+  @Autowired(IEditorDocumentModelService)
+  documentModelManager: IEditorDocumentModelService;
+
+  @Autowired(PreferenceService)
+  private readonly preferenceService: PreferenceService;
+
+  @Autowired(IMultiDiffSourceResolverService)
+  private readonly multiDiffSourceResolverService: IMultiDiffSourceResolverService;
+
+  private multiDiffModelChangeEmitter = new Emitter<IMultiDiffEditorModel>();
+  public readonly onMultiDiffModelChange = this.multiDiffModelChangeEmitter.event;
+
+  private viewStateMap: Map<string, any> = new Map();
+  private currentUri: URI | undefined;
+
+  private multiDiffModel: IMultiDiffEditorModel & IDisposable;
+
+  constructor(private multiDiffWidget: MultiDiffEditorWidget, private convertedOptions: IConvertedMonacoOptions) {
+    super();
+  }
+
+  @OnEvent(EditorDocumentModelContentChangedEvent)
+  onDocModelContentChangedEvent(e: EditorDocumentModelContentChangedEvent) {
+    if (!this.currentUri) {
+      return;
+    }
+    // TODO: 目前的设计下，不支持动态修改 resource 的 name，diff 数量变化时会有问题
+    if (
+      this.multiDiffModel?.documents.value === 'loading' ||
+      !this.multiDiffModel.documents.value.some(
+        (document) => document.object.modified?.uri.toString() === e.payload.uri.codeUri.toString(),
+      )
+    ) {
+      return;
+    }
+    this.eventBus.fire(
+      new ResourceDecorationNeedChangeEvent({
+        uri: this.currentUri,
+        decoration: {
+          dirty: !!e.payload.dirty,
+          readOnly: !!e.payload.readonly,
+        },
+      }),
+    );
+  }
+
+  private saveViewState(uri: URI) {
+    if (!uri) {
+      return;
+    }
+    const key = uri.toString();
+    const state = this.multiDiffWidget.getViewState();
+    if (state) {
+      this.viewStateMap.set(key, state);
+    }
+  }
+
+  private restoreViewState(uri: URI) {
+    if (!uri) {
+      return;
+    }
+    const key = uri.toString();
+    const state = this.viewStateMap.get(key);
+    if (state) {
+      this.multiDiffWidget.setViewState(state);
+    }
+  }
+
+  async compareMultiple(resource: IResource, options?: IResourceOpenOptions): Promise<void> {
+    // Save current view state before changing
+    if (this.currentUri) {
+      this.saveViewState(this.currentUri);
+    }
+
+    const source: IResolvedMultiDiffSource | undefined = resource.metadata.sources?.length
+      ? { resources: ValueWithChangeEvent.const(resource.metadata.sources) }
+      : await this.multiDiffSourceResolverService.resolve(resource.uri);
+    const resources = source ? observableFromValueWithChangeEvent(this, source.resources) : constObservable([]);
+
+    const documentsWithPromises = mapObservableArrayCached(
+      this,
+      resources,
+      async (r, store) => {
+        /** @description documentsWithPromises */
+        let original: IEditorDocumentModelRef | undefined;
+        let modified: IEditorDocumentModelRef | undefined;
+
+        const multiDiffItemStore = new DisposableStore();
+
+        try {
+          [original, modified] = await Promise.all([
+            r.originalUri ? this.documentModelManager.createModelReference(r.originalUri) : undefined,
+            r.modifiedUri ? this.documentModelManager.createModelReference(r.modifiedUri) : undefined,
+          ]);
+          // console.log('original', original, 'modified', modified);
+          if (original) {
+            multiDiffItemStore.add(original);
+          }
+          if (modified) {
+            multiDiffItemStore.add(modified);
+          }
+        } catch (e) {
+          // e.g. "File seems to be binary and cannot be opened as text"
+          this.messageService.error(e.message);
+          // eslint-disable-next-line no-console
+          console.error(e);
+          return undefined;
+        }
+        const uri = (r.modifiedUri ?? r.originalUri)!;
+        const result = {
+          multiDiffEditorItem: r,
+          original: original?.instance.getMonacoModel(),
+          modified: modified?.instance.getMonacoModel(),
+          contextKeys: r.contextKeys,
+          options: {
+            readOnly: modified?.instance.readonly,
+            // TODO: codelens，wordWrap options
+            ...this.convertedOptions.diffOptions,
+          },
+          // TODO: 监听配置变化验证
+          onOptionsDidChange: (h) =>
+            this.preferenceService.onPreferenceChanged((e) => {
+              if (e.affects(uri.toString()) && e.preferenceName.includes('editor')) {
+                h();
+              }
+            }),
+        };
+        return store.add(RefCounted.createOfNonDisposable(result, multiDiffItemStore, this));
+      },
+      (i) => JSON.stringify([i.modifiedUri?.toString(), i.originalUri?.toString()]),
+    );
+
+    const documents = observableValue<readonly RefCounted<IDocumentDiffItem>[] | 'loading'>('documents', 'loading');
+
+    const updateDocuments = derived(async (reader) => {
+      /** @description Update documents */
+      const docsPromises = documentsWithPromises.read(reader);
+      const docs = await Promise.all(docsPromises);
+      const newDocuments = docs.filter((item) => item !== undefined);
+      documents.set(newDocuments, undefined);
+    });
+
+    const a = recomputeInitiallyAndOnChange(updateDocuments);
+    await updateDocuments.get();
+    this.multiDiffModel?.dispose();
+    this.multiDiffModel = {
+      dispose: () => a.dispose(),
+      documents: new ValueWithChangeEventFromObservable(documents),
+      contextKeys: source?.contextKeys,
+    };
+
+    const viewModel = this.multiDiffWidget.createViewModel(this.multiDiffModel);
+    await viewModel.waitForDiffs();
+    this.multiDiffWidget.setViewModel(viewModel);
+
+    // Update current URI and restore view state
+    this.currentUri = resource.uri;
+    this.restoreViewState(resource.uri);
+
+    this.multiDiffModelChangeEmitter.fire(this.multiDiffModel);
+  }
+
+  getDiffEntry(uri: URI): IDocumentDiffItem | undefined {
+    return this.multiDiffWidget.findDocumentDiffItem(uri.codeUri);
+  }
+
+  getCurrentDiffEntry(): IDocumentDiffItem | undefined {
+    const activeControl = this.multiDiffWidget.getActiveControl();
+    if (!activeControl) {
+      return undefined;
+    }
+    const originalUri = activeControl.getOriginalEditor().getModel()?.uri;
+    if (!originalUri) {
+      return undefined;
+    }
+    return this.multiDiffWidget.findDocumentDiffItem(originalUri);
+  }
+
+  reveal(resource: IMultiDiffResourceId, options?: { range?: Range; highlight: boolean }): void {
+    this.multiDiffWidget.reveal(resource, options);
+  }
+
+  layout(dimension: Dimension): void {
+    this.multiDiffWidget.layout(dimension);
+  }
+
+  focus(): void {
+    const activeControl = this.multiDiffWidget.getActiveControl();
+    if (activeControl) {
+      activeControl.focus();
+    }
+  }
+
+  tryGetCodeEditor(uri: URI): { diffEditor: IDiffEditor; editor: ICodeEditor } | undefined {
+    return this.multiDiffWidget.tryGetCodeEditor(uri.codeUri);
+  }
+
+  dispose(): void {
+    super.dispose();
+    this.multiDiffWidget.dispose();
+  }
+}

package/src/browser/multi-diff/multi-diff-resolver.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-common';
+import { ValueWithChangeEvent } from '@opensumi/monaco-editor-core/esm/vs/base/common/event';
+
+import {
+  IMultiDiffSourceResolver,
+  IResolvedMultiDiffSource,
+  MULTI_DIFF_SCHEME,
+  MultiDiffEditorItem,
+} from '../../common/multi-diff';
+
+@Injectable()
+export class MultiDiffResolver implements IMultiDiffSourceResolver {
+  private readonly sourceValues = new Map<string, ValueWithChangeEvent<MultiDiffEditorItem[]>>();
+
+  registerSources(uri: URI, sources: MultiDiffEditorItem[]) {
+    const key = uri.toString();
+    const saved = this.sourceValues.get(key);
+    if (saved) {
+      saved.value = sources;
+    } else {
+      this.sourceValues.set(key, new ValueWithChangeEvent(sources));
+    }
+  }
+
+  canHandleUri(uri: URI): boolean {
+    return uri.scheme === MULTI_DIFF_SCHEME;
+  }
+
+  async resolveDiffSource(uri: URI): Promise<IResolvedMultiDiffSource | undefined> {
+    const value = this.sourceValues.get(uri.toString());
+    if (!value) {
+      return undefined;
+    }
+
+    return {
+      resources: value,
+    };
+  }
+
+  dispose() {
+    this.sourceValues.clear();
+  }
+}

package/src/browser/multi-diff/multi-diff-resource.ts

@@ -0,0 +1,59 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { AppConfig, URI, WithEventBus, getIcon } from '@opensumi/ide-core-browser';
+import { LabelService } from '@opensumi/ide-core-browser/lib/services';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+import { IResourceProvider, ResourceService } from '../../common';
+import { IMultiDiffSourceResolverService } from '../../common/multi-diff';
+
+@Injectable()
+export class MultiDiffResourceProvider extends WithEventBus implements IResourceProvider {
+  @Autowired()
+  labelService: LabelService;
+
+  @Autowired(ResourceService)
+  resourceService: ResourceService;
+
+  @Autowired(IFileServiceClient)
+  protected fileServiceClient: IFileServiceClient;
+
+  @Autowired(AppConfig)
+  protected readonly appConfig: AppConfig;
+
+  @Autowired(IMultiDiffSourceResolverService)
+  private readonly multiDiffSourceResolverService: IMultiDiffSourceResolverService;
+
+  handlesUri(uri: URI): number {
+    const resolvers = this.multiDiffSourceResolverService.getResolvers();
+    for (const resolver of resolvers) {
+      if (resolver.canHandleUri(uri)) {
+        return 10;
+      }
+    }
+    return -1;
+  }
+
+  async provideResource(uri: URI) {
+    const { name, sources } = uri.getParsedQuery();
+    const parsedSources = sources ? JSON.parse(sources) : [];
+
+    // Get icon from the first modified file
+    const firstModifiedUri = parsedSources.length > 0 ? new URI(parsedSources[0].modifiedUri) : undefined;
+    const icon = firstModifiedUri ? this.labelService.getIcon(firstModifiedUri) : undefined;
+
+    return {
+      name: `Multi-Diff: ${name || parsedSources.length + ' files'}`,
+      icon: icon || getIcon('diff'),
+      uri,
+      supportsRevive: this.appConfig.enableDiffRevive ?? false,
+      metadata: {
+        sources: parsedSources,
+      },
+    };
+  }
+
+  async shouldCloseResource(resource, openedResources): Promise<boolean> {
+    // TODO: For now, always allow closing
+    return true;
+  }
+}

package/src/browser/multi-diff/multi-diff.contribution.ts

@@ -0,0 +1,54 @@
+import { Autowired } from '@opensumi/di';
+import { Domain, IDisposable, URI } from '@opensumi/ide-core-browser';
+
+import { ResourceService } from '../../common';
+import { IMultiDiffSourceResolverService, IResolvedMultiDiffSource, MULTI_DIFF_SCHEME } from '../../common/multi-diff';
+import {
+  BrowserEditorContribution,
+  EditorComponentRegistry,
+  EditorOpenType,
+  MultiDiffSourceContribution,
+} from '../types';
+
+import { MultiDiffResolver } from './multi-diff-resolver';
+import { MultiDiffResourceProvider } from './multi-diff-resource';
+
+@Domain(BrowserEditorContribution, MultiDiffSourceContribution)
+export class MultiDiffEditorContribution implements BrowserEditorContribution, MultiDiffSourceContribution {
+  @Autowired(IMultiDiffSourceResolverService)
+  private readonly multiDiffSourceResolverService: IMultiDiffSourceResolverService;
+
+  @Autowired(MultiDiffResolver)
+  private readonly multiDiffResolver: MultiDiffResolver;
+
+  @Autowired()
+  private readonly multiDiffResourceProvider: MultiDiffResourceProvider;
+
+  registerMultiDiffSourceResolver(resolverService: IMultiDiffSourceResolverService): IDisposable {
+    // 内置实现，通过 command 使用
+    return resolverService.registerResolver(this.multiDiffResolver);
+  }
+
+  registerResource(resourceService: ResourceService): void {
+    resourceService.registerResourceProvider(this.multiDiffResourceProvider);
+  }
+
+  registerEditorComponent(registry: EditorComponentRegistry) {
+    registry.registerEditorComponentResolver(
+      (scheme) => {
+        const resolvers = this.multiDiffSourceResolverService.getResolvers();
+        for (const resolver of resolvers) {
+          if (resolver.canHandleUri(new URI(`${scheme}:/empty`))) {
+            return 10;
+          }
+        }
+        return -1;
+      },
+      (resource, results) => {
+        results.push({
+          type: EditorOpenType.multiDiff,
+        });
+      },
+    );
+  }
+}

package/src/browser/multi-diff/resolver.service.ts

@@ -0,0 +1,35 @@
+import { Injectable } from '@opensumi/di';
+import { IDisposable, URI, toDisposable } from '@opensumi/ide-utils';
+
+import {
+  IMultiDiffSourceResolver,
+  IMultiDiffSourceResolverService,
+  IResolvedMultiDiffSource,
+} from '../../common/multi-diff';
+
+@Injectable()
+export class MultiDiffSourceResolverService implements IMultiDiffSourceResolverService {
+  private readonly _resolvers = new Set<IMultiDiffSourceResolver>();
+
+  registerResolver(resolver: IMultiDiffSourceResolver): IDisposable {
+    // throw on duplicate
+    if (this._resolvers.has(resolver)) {
+      throw new Error('Duplicate resolver');
+    }
+    this._resolvers.add(resolver);
+    return toDisposable(() => this._resolvers.delete(resolver));
+  }
+
+  resolve(uri: URI): Promise<IResolvedMultiDiffSource | undefined> {
+    for (const resolver of this._resolvers) {
+      if (resolver.canHandleUri(uri)) {
+        return resolver.resolveDiffSource(uri);
+      }
+    }
+    return Promise.resolve(undefined);
+  }
+
+  getResolvers(): IMultiDiffSourceResolver[] {
+    return Array.from(this._resolvers);
+  }
+}