@opensumi/ide-editor 3.1.4-next-1719541057.0 → 3.1.5-next-1719913150.0

package/src/browser/merge-conflict/merge-conflict.model.ts

@@ -0,0 +1,63 @@
+import debounce from 'lodash/debounce';
+import { useEffect, useMemo, useState } from 'react';
+
+import { formatLocalize, useInjectable } from '@opensumi/ide-core-browser';
+import { DisposableStore, URI } from '@opensumi/ide-utils';
+
+import { useEditorDocumentModelRef } from '../hooks/useEditor';
+
+import { MergeConflictService } from './merge-conflict.service';
+
+export function useMergeConflictModel(uri: URI) {
+  const editorModel = useEditorDocumentModelRef(uri);
+
+  /**
+   * 如果是原来就有冲突的文件，当冲突没了之后，仍然显示冲突
+   */
+  const [isInitialVisiable, setIsInitialVisiable] = useState(false);
+  const [conflictsCount, setConflictsCount] = useState(0);
+
+  const mergeConflictService = useInjectable<MergeConflictService>(MergeConflictService);
+
+  const summary = useMemo(
+    () => formatLocalize('merge-conflicts.merge.conflict.remain', conflictsCount),
+    [conflictsCount],
+  );
+
+  useEffect(() => {
+    const disposables = new DisposableStore();
+
+    if (editorModel) {
+      const { instance } = editorModel;
+      const run = () => {
+        const n = mergeConflictService.scanDocument(instance.getMonacoModel());
+        setConflictsCount(n);
+        if (n > 0) {
+          setIsInitialVisiable(true);
+        }
+      };
+
+      const debounceRun = debounce(run, 150);
+
+      disposables.add(
+        instance.getMonacoModel().onDidChangeContent(() => {
+          debounceRun();
+        }),
+      );
+
+      run();
+      return () => {
+        disposables.dispose();
+        mergeConflictService.clear();
+        setIsInitialVisiable(false);
+        setConflictsCount(0);
+      };
+    }
+  }, [editorModel]);
+
+  return {
+    isVisiable: isInitialVisiable,
+    summary,
+    canNavigate: conflictsCount > 0,
+  };
+}

package/src/browser/merge-conflict/merge-conflict.service.ts

@@ -0,0 +1,65 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import * as monaco from '@opensumi/ide-monaco';
+import { NavigationDirection, findRangeForNavigation } from '@opensumi/ide-monaco/lib/browser/contrib/merge-editor';
+import { IMessageService } from '@opensumi/ide-overlay';
+
+import { IEditor, WorkbenchEditorService } from '../types';
+
+import { DocumentMergeConflict, MergeConflictParser } from './conflict-parser';
+
+@Injectable()
+export class MergeConflictService {
+  @Autowired(MergeConflictParser)
+  parser: MergeConflictParser;
+
+  @Autowired(WorkbenchEditorService)
+  private readonly editorService: WorkbenchEditorService;
+
+  @Autowired(IMessageService)
+  private readonly messageService: IMessageService;
+
+  conflicts = [] as DocumentMergeConflict[];
+
+  scanDocument(model: monaco.editor.ITextModel) {
+    this.conflicts = this.parser.scanDocument(model);
+    return this.conflicts.length;
+  }
+
+  clear(): void {
+    this.conflicts = [];
+  }
+
+  private async navigate(editor: IEditor, direction: NavigationDirection): Promise<void> {
+    this.conflicts = this.parser.scanDocument(editor.monacoEditor.getModel()!);
+    const ranges = this.conflicts.map((conflict) => conflict.range);
+
+    const navigationResult = findRangeForNavigation(direction, ranges, editor.monacoEditor.getPosition()!);
+
+    if (!navigationResult) {
+      this.messageService.warning('No merge conflicts found in this file');
+      return;
+    } else if (!navigationResult.canNavigate) {
+      this.messageService.warning('No other merge conflicts within this file');
+      return;
+    } else if (!navigationResult.range) {
+      // impossible path
+      return;
+    }
+
+    editor.monacoEditor.setPosition(navigationResult.range.getStartPosition());
+
+    // when navigating, we want to show the codelens on the first line of the conflict
+    const range = navigationResult.range.delta(-1);
+
+    editor.monacoEditor.revealRangeNearTopIfOutsideViewport(range);
+    editor.monacoEditor.focus();
+  }
+
+  navigateNext(): Promise<void> {
+    return this.navigate(this.editorService.currentEditor!, NavigationDirection.Forwards);
+  }
+
+  navigatePrevious(): Promise<void> {
+    return this.navigate(this.editorService.currentEditor!, NavigationDirection.Backwards);
+  }
+}

package/src/browser/merge-conflict/types.ts

@@ -41,27 +41,6 @@ export interface ICacheDocumentMergeConflict extends IDocumentMergeConflictDescr
   aiContent?: string;
 }
 
-export interface IDocumentMergeConflictTracker {
-  getConflicts(document: monaco.editor.ITextModel): PromiseLike<IDocumentMergeConflict[]>;
-  isPending(document: monaco.editor.ITextModel): boolean;
-  forget(document: monaco.editor.ITextModel): void;
-}
-
-export interface IDocumentMergeConflictTrackerService {
-  createTracker(origin: string): IDocumentMergeConflictTracker;
-  forget(document: monaco.editor.ITextModel): void;
-}
-
-export interface IDocumentMergeConflictNavigationResults {
-  canNavigate: boolean;
-  conflict?: IDocumentMergeConflict;
-}
-
-export enum NavigationDirection {
-  Forwards,
-  Backwards,
-}
-
 export namespace AI_COMMAND {
   const MERGE_CONFLICT = 'merge-conflict';
   export const ACCEPT = `${MERGE_CONFLICT}.ai.accept`;

package/src/browser/merge-editor/MergeEditorFloatComponents.tsx

@@ -1,72 +1,37 @@
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useState } from 'react';
 
 import {
   CommandRegistry,
   CommandService,
-  DisposableStore,
   MERGE_CONFLICT_COMMANDS,
   SCM_COMMANDS,
   URI,
   useInjectable,
 } from '@opensumi/ide-core-browser';
-import { formatLocalize } from '@opensumi/ide-core-common';
-import { MergeConflictCommands } from '@opensumi/ide-core-common/lib/commands/git';
 import { MergeActions } from '@opensumi/ide-monaco/lib/browser/contrib/merge-editor/components/merge-actions';
 
-import { useEditorDocumentModelRef } from '../hooks/useEditor';
-import { DocumentMergeConflict, MergeConflictParser } from '../merge-conflict';
+import { useMergeConflictModel } from '../merge-conflict/merge-conflict.model';
+import { MergeConflictService } from '../merge-conflict/merge-conflict.service';
 import { ReactEditorComponent } from '../types';
 
 export const MergeEditorFloatComponents: ReactEditorComponent<{ uri: URI }> = ({ resource }) => {
   const { uri } = resource;
-  const editorModel = useEditorDocumentModelRef(uri);
-  const mergeConflictParser: MergeConflictParser = useInjectable(MergeConflictParser);
+  const mergeConflictService = useInjectable<MergeConflictService>(MergeConflictService);
   const commandService = useInjectable<CommandService>(CommandService);
   const commandRegistry = useInjectable<CommandRegistry>(CommandRegistry);
 
-  const [isVisiable, setIsVisiable] = useState(false);
-  const [conflicts, setConflicts] = useState<DocumentMergeConflict[]>([]);
-
-  useEffect(() => {
-    const disposables = new DisposableStore();
-
-    if (editorModel) {
-      const { instance } = editorModel;
-      const run = () => {
-        const conflicts = mergeConflictParser.scanDocument(instance.getMonacoModel());
-        if (conflicts.length > 0) {
-          setIsVisiable(true);
-          setConflicts(conflicts);
-        } else {
-          setIsVisiable(false);
-          setConflicts([]);
-        }
-      };
-
-      disposables.add(
-        editorModel.instance.getMonacoModel().onDidChangeContent(() => {
-          run();
-        }),
-      );
-      run();
-      return () => {
-        disposables.dispose();
-      };
-    }
-  }, [editorModel]);
+  const { canNavigate, isVisiable, summary } = useMergeConflictModel(uri);
 
   const [isAIResolving, setIsAIResolving] = useState(false);
+
   const handlePrev = useCallback(() => {
-    commandService.tryExecuteCommand(MergeConflictCommands.Previous).then(() => {
-      // TODO: 编辑器向上滚动一行
-    });
+    mergeConflictService.navigatePrevious();
   }, []);
 
   const handleNext = useCallback(() => {
-    commandService.tryExecuteCommand(MergeConflictCommands.Next).then(() => {
-      // TODO: 编辑器向上滚动一行
-    });
+    mergeConflictService.navigateNext();
   }, []);
+
   const handleAIResolve = useCallback(async () => {
     setIsAIResolving(true);
     if (isAIResolving) {
@@ -81,12 +46,12 @@ export const MergeEditorFloatComponents: ReactEditorComponent<{ uri: URI }> = ({
     return null;
   }
 
-  const summary = formatLocalize('merge-conflicts.merge.conflict.remain', conflicts.length);
   return (
     <MergeActions
       uri={uri}
       editorType='text'
       summary={summary}
+      canNavigate={canNavigate}
       handleNext={handleNext}
       handlePrev={handlePrev}
       isAIResolving={isAIResolving}

package/src/browser/preference/schema.ts

@@ -1631,7 +1631,7 @@ const customEditorSchema: PreferenceSchemaProperties = {
   },
   'editor.largeFile': {
     type: 'number',
-    default: 4 * 1024 * 1024 * 1024,
+    default: 4 * 1024 * 1024 * 1024, // 4096 MB
     description: '%editor.configuration.largeFileSize%',
   },
   'editor.quickSuggestionsDelay': {

package/src/browser/tab.view.tsx

@@ -391,6 +391,7 @@ export const Tabs = ({ group }: ITabsProps) => {
     const curTabIndex = group.resources.findIndex((resource) => group.currentResource === resource);
     return (
       <div
+        draggable={false}
         className={cls({
           [styles_kt_editor_tabs_content]: true,
           [styles_kt_editor_tabs_current_last]: curTabIndex === group.resources.length - 1,

package/src/browser/types.ts

@@ -114,13 +114,10 @@ export class RegisterEditorComponentEvent extends BasicEvent<string> {}
 export abstract class EditorComponentRegistry {
   abstract registerEditorComponent<T>(component: IEditorComponent<T>, initialProps?: any): IDisposable;
 
-  // 等同于 handlesScheme => 10
-  abstract registerEditorComponentResolver<T>(scheme: string, resolver: IEditorComponentResolver<T>): IDisposable;
-
-  // handlesScheme 返回权重， 小于 0 表示不处理
   abstract registerEditorComponentResolver<T>(
-    // eslint-disable-next-line @typescript-eslint/unified-signatures
-    handlesScheme: (scheme: string) => number,
+    handlesScheme:
+      | string // 等同于 handlesScheme => 10
+      | ((scheme: string) => number), // handlesScheme 返回权重， 小于 0 表示不处理
     resolver: IEditorComponentResolver<T>,
   ): IDisposable;
 

package/src/common/editor.ts

@@ -257,6 +257,8 @@ export interface IDiffEditor extends IDisposable {
   focus(): void;
 
   getLineChanges(): ILineChange[] | null;
+
+  onRefOpen: Event<IEditorDocumentModelRef>;
 }
 
 @Injectable()