@opensumi/ide-terminal-next 3.7.1 → 3.7.2-next-1739859371.0

package/src/browser/links/link-manager.ts

@@ -41,6 +41,7 @@ import {
   winLineAndColumnMatchIndex,
   winLocalLinkClause,
 } from './validated-local-link-provider';
+import { TerminalWordLinkProvider } from './word-link-provider';
 
 const { posix, win32 } = path;
 
@@ -136,6 +137,13 @@ export class TerminalLinkManager extends Disposable {
     ]);
     this._standardLinkProviders.push(validatedProvider);
 
+    const wordLinkProvider = this.injector.get(TerminalWordLinkProvider, [
+      this._xterm,
+      async (link, cb) => cb(await this._resolvePath(link)),
+      wrappedTextLinkActivateCallback,
+    ]);
+    this._standardLinkProviders.push(wordLinkProvider);
+
     this._registerStandardLinkProviders();
   }
 
@@ -165,8 +173,8 @@ export class TerminalLinkManager extends Disposable {
   ) {
     const core = (this._xterm as any)._core as XTermCore;
     const cellDimensions = {
-      width: core._renderService.dimensions.actualCellWidth,
-      height: core._renderService.dimensions.actualCellHeight,
+      width: core._renderService.dimensions.css.cell.width,
+      height: core._renderService.dimensions.css.cell.height,
     };
     const terminalDimensions = {
       width: this._xterm.cols,
@@ -375,13 +383,8 @@ export class TerminalLinkManager extends Disposable {
       return undefined;
     }
 
-    const linkUrl = this.extractLinkUrl(preprocessedLink);
-    if (!linkUrl) {
-      return undefined;
-    }
-
     try {
-      const uri = URI.file(linkUrl);
+      const uri = URI.file(preprocessedLink);
       const stat = await this._fileService.getFileStat(uri.toString());
       if (stat) {
         return { uri, isDirectory: stat.isDirectory };

package/src/browser/links/validated-local-link-provider.ts

@@ -138,7 +138,6 @@ export class TerminalValidatedLocalLinkProvider extends TerminalBaseLinkProvider
     let match;
     let stringIndex = -1;
     while ((match = rex.exec(text)) !== null) {
-      // const link = match[typeof matcher.matchIndex !== 'number' ? 0 : matcher.matchIndex];
       let link = match[0];
       if (!link) {
         // something matched but does not comply with the given matchIndex
@@ -169,60 +168,81 @@ export class TerminalValidatedLocalLinkProvider extends TerminalBaseLinkProvider
         link = link.substring(2);
         stringIndex += 2;
       }
+      const validatedLinks = await this.detectLocalLink(link, lines, startLine, stringIndex, 1);
 
-      // Convert the link text's string index into a wrapped buffer range
-      const bufferRange = convertLinkRangeToBuffer(
-        lines,
-        this._xterm.cols,
-        {
-          startColumn: stringIndex + 1,
-          startLineNumber: 1,
-          endColumn: stringIndex + link.length + 1,
-          endLineNumber: 1,
-        },
-        startLine,
-      );
-
-      const validatedLink = await new Promise<TerminalLink | undefined>((r) => {
-        this._validationCallback(link, async (result) => {
-          if (result) {
-            const label = result.isDirectory
-              ? (await this._isDirectoryInsideWorkspace(result.uri))
-                ? FOLDER_IN_WORKSPACE_LABEL
-                : FOLDER_NOT_IN_WORKSPACE_LABEL
-              : OPEN_FILE_LABEL;
-            const activateCallback = this._wrapLinkHandler((event: MouseEvent | undefined, text: string) => {
-              if (result.isDirectory) {
-                this._handleLocalFolderLink(result.uri);
-              } else {
-                this._activateFileCallback(event, text);
-              }
-            });
-            r(
-              this.injector.get(TerminalLink, [
-                this._xterm,
-                bufferRange,
-                link,
-                this._xterm.buffer.active.viewportY,
-                activateCallback,
-                this._tooltipCallback,
-                true,
-                label,
-              ]),
-            );
-          } else {
-            r(undefined);
-          }
-        });
-      });
-      if (validatedLink) {
-        result.push(validatedLink);
+      if (validatedLinks.length > 0) {
+        result.push(...validatedLinks);
+      }
+    }
+
+    if (result.length === 0) {
+      const validatedLinks = await this.detectLocalLink(text, lines, startLine, stringIndex, 2);
+      if (validatedLinks.length > 0) {
+        result.push(...validatedLinks);
       }
     }
 
     return result;
   }
 
+  private async detectLocalLink(
+    text: string,
+    bufferLines: IBufferLine[],
+    startLine: number,
+    stringIndex: number,
+    offset,
+  ) {
+    const result: TerminalLink[] = [];
+    const validatedLink = await new Promise<TerminalLink | undefined>((r) => {
+      this._validationCallback(text, async (result) => {
+        if (result) {
+          const label = result.isDirectory
+            ? (await this._isDirectoryInsideWorkspace(result.uri))
+              ? FOLDER_IN_WORKSPACE_LABEL
+              : FOLDER_NOT_IN_WORKSPACE_LABEL
+            : OPEN_FILE_LABEL;
+          const activateCallback = this._wrapLinkHandler((event: MouseEvent | undefined, text: string) => {
+            if (result.isDirectory) {
+              this._handleLocalFolderLink(result.uri);
+            } else {
+              this._activateFileCallback(event, text);
+            }
+          });
+          // Convert the link text's string index into a wrapped buffer range
+          const bufferRange = convertLinkRangeToBuffer(
+            bufferLines,
+            this._xterm.cols,
+            {
+              startColumn: stringIndex + 1,
+              startLineNumber: 1,
+              endColumn: stringIndex + text.length + offset,
+              endLineNumber: 1,
+            },
+            startLine,
+          );
+          r(
+            this.injector.get(TerminalLink, [
+              this._xterm,
+              bufferRange,
+              text,
+              this._xterm.buffer.active.viewportY,
+              activateCallback,
+              this._tooltipCallback,
+              true,
+              label,
+            ]),
+          );
+        } else {
+          r(undefined);
+        }
+      });
+    });
+    if (validatedLink) {
+      result.push(validatedLink);
+    }
+    return result;
+  }
+
   protected get _localLinkRegex(): RegExp {
     const baseLocalLinkClause = this._client.os === OperatingSystem.Windows ? winLocalLinkClause : unixLocalLinkClause;
     // Append line and column number regex

package/src/browser/links/word-link-provider.ts

@@ -0,0 +1,175 @@
+import { IBufferLine, Terminal } from '@xterm/xterm';
+
+import { Autowired, INJECTOR_TOKEN, Injectable, Injector } from '@opensumi/di';
+import { PrefixQuickOpenService } from '@opensumi/ide-core-browser/lib/quick-open';
+import { AppConfig } from '@opensumi/ide-core-browser/lib/react-providers/config-provider';
+import { IWindowService } from '@opensumi/ide-core-browser/lib/window';
+import { URI } from '@opensumi/ide-core-common';
+import { CommandService } from '@opensumi/ide-core-common/lib/command';
+import { IWorkspaceService } from '@opensumi/ide-workspace/lib/common/workspace.interface';
+
+import { escapeRegExpCharacters } from '../terminal.typeAhead.addon';
+
+import { TerminalBaseLinkProvider } from './base';
+import { convertLinkRangeToBuffer, getXtermLineContent } from './helpers';
+import { TerminalLink } from './link';
+
+export const USUAL_WORD_SEPARATORS = ' ()[]{}\',"`─‘’“”|';
+
+interface Word {
+  startIndex: number;
+  endIndex: number;
+  text: string;
+}
+
+@Injectable({ multiple: true })
+export class TerminalWordLinkProvider extends TerminalBaseLinkProvider {
+  private _separatorRegex!: RegExp;
+
+  @Autowired(AppConfig)
+  private readonly appConfig: AppConfig;
+
+  @Autowired(CommandService)
+  private readonly commandService: CommandService;
+
+  @Autowired(IWindowService)
+  protected readonly windowService: IWindowService;
+
+  @Autowired(INJECTOR_TOKEN)
+  private readonly injector: Injector;
+
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: IWorkspaceService;
+
+  @Autowired(PrefixQuickOpenService)
+  protected readonly quickOpenService: PrefixQuickOpenService;
+
+  constructor(
+    private readonly _xterm: Terminal,
+    private readonly _validationCallback: (
+      link: string,
+      callback: (result: { uri: URI; isDirectory: boolean } | undefined) => void,
+    ) => void,
+    private readonly _activateFileCallback: (event: MouseEvent | undefined, link: string) => void,
+  ) {
+    super();
+    this._refreshSeparatorCodes();
+  }
+
+  private _refreshSeparatorCodes(): void {
+    let powerlineSymbols = '';
+    for (let i = 0xe0b0; i <= 0xe0bf; i++) {
+      powerlineSymbols += String.fromCharCode(i);
+    }
+    this._separatorRegex = new RegExp(`[${escapeRegExpCharacters(USUAL_WORD_SEPARATORS)}${powerlineSymbols}]`, 'g');
+  }
+
+  protected _provideLinks(bufferLineNumber: number): Promise<TerminalLink[]> | TerminalLink[] {
+    const links: TerminalLink[] = [];
+    const startLine = bufferLineNumber - 1;
+    const endLine = startLine;
+
+    const lines: IBufferLine[] = [this._xterm.buffer.active.getLine(startLine)!];
+
+    const text = getXtermLineContent(this._xterm.buffer.active, startLine, endLine, this._xterm.cols);
+    if (text === '' || text.length > 1024) {
+      return [];
+    }
+
+    // Parse out all words from the wrapped line
+    const words: Word[] = this._parseWords(text);
+
+    // Map the words to ITerminalLink objects
+    for (const word of words) {
+      if (word.text === '') {
+        continue;
+      }
+
+      if (word.text.length > 0 && word.text.charAt(word.text.length - 1) === ':') {
+        word.text = word.text.slice(0, -1);
+        word.endIndex--;
+      }
+
+      const bufferRange = convertLinkRangeToBuffer(
+        lines,
+        this._xterm.cols,
+        {
+          startColumn: word.startIndex + 1,
+          startLineNumber: 1,
+          endColumn: word.endIndex + 1,
+          endLineNumber: 1,
+        },
+        startLine,
+      );
+
+      // Search links
+      const activateHandler = (event: MouseEvent | undefined, text: string) => {
+        this._validationCallback(text, async (result) => {
+          if (result) {
+            if (result.isDirectory) {
+              this._handleLocalFolderLink(result.uri);
+            } else {
+              this._activateFileCallback(event, text);
+            }
+          } else {
+            this.quickOpenService.open(text);
+          }
+        });
+      };
+
+      links.push(
+        this.injector.get(TerminalLink, [
+          this._xterm,
+          bufferRange,
+          word.text,
+          this._xterm.buffer.active.viewportY,
+          activateHandler,
+          undefined,
+          true,
+          word.text,
+        ]),
+      );
+    }
+
+    return links;
+  }
+
+  private async _handleLocalFolderLink(uri: URI): Promise<void> {
+    // If the folder is within one of the window's workspaces, focus it in the explorer
+    if (await this._isDirectoryInsideWorkspace(uri)) {
+      await this.commandService.executeCommand('revealInExplorer', uri);
+      return;
+    }
+
+    // Open a new window for the folder
+    if (this.appConfig.isElectronRenderer) {
+      this.windowService.openWorkspace(uri, { newWindow: true });
+    }
+  }
+
+  private _parseWords(text: string): Word[] {
+    const words: Word[] = [];
+    const splitWords = text.split(this._separatorRegex);
+    let runningIndex = 0;
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < splitWords.length; i++) {
+      words.push({
+        text: splitWords[i],
+        startIndex: runningIndex,
+        endIndex: runningIndex + splitWords[i].length,
+      });
+      runningIndex += splitWords[i].length + 1;
+    }
+    return words;
+  }
+
+  private async _isDirectoryInsideWorkspace(uri: URI) {
+    const folders = await this.workspaceService.roots;
+    for (const folder of folders) {
+      if (URI.parse(folder.uri).isEqualOrParent(uri)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/src/browser/terminal.client.ts

@@ -1,3 +1,5 @@
+import { ISearchOptions } from '@xterm/addon-search';
+
 import { Autowired, INJECTOR_TOKEN, Injectable, Injector } from '@opensumi/di';
 import { IEventBus, QuickPickService, TerminalClientAttachEvent, localize } from '@opensumi/ide-core-browser';
 import { PreferenceService } from '@opensumi/ide-core-browser/lib/preferences/types';
@@ -729,9 +731,18 @@ export class TerminalClient extends Disposable implements ITerminalClient {
     return this.xterm.raw.paste(text);
   }
 
-  findNext(text: string) {
+  findNext(text: string, searchOptions: ISearchOptions = {}) {
+    this._checkReady();
+    return this.xterm.findNext(text, searchOptions);
+  }
+
+  findPrevious(text: string, searchOptions: ISearchOptions = {}) {
     this._checkReady();
-    return this.xterm.findNext(text);
+    return this.xterm.findPrevious(text, searchOptions);
+  }
+
+  get onSearchResultsChange() {
+    return this.xterm.onSearchResultsChange;
   }
 
   closeSearch() {

package/src/browser/terminal.controller.ts

@@ -23,7 +23,6 @@ import {
 } from '@opensumi/ide-core-common';
 import { WorkbenchEditorService } from '@opensumi/ide-editor';
 import { IMainLayoutService } from '@opensumi/ide-main-layout';
-import { TabBarHandler } from '@opensumi/ide-main-layout/lib/browser/tabbar-handler';
 import { IThemeService } from '@opensumi/ide-theme';
 
 import {
@@ -62,7 +61,6 @@ import { TerminalGroupViewService } from './terminal.view';
 @Injectable()
 export class TerminalController extends WithEventBus implements ITerminalController {
   protected _focus: boolean;
-  protected _tabBarHandler: TabBarHandler | undefined;
   protected _clients: Map<string, ITerminalClient>;
   protected _onDidOpenTerminal = new Emitter<ITerminalInfo>();
   protected _onDidCloseTerminal = new Emitter<ITerminalExitEvent>();
@@ -199,6 +197,10 @@ export class TerminalController extends WithEventBus implements ITerminalControl
     return this._clientId;
   }
 
+  get _tabBarHandler() {
+    return this.layoutService.getTabbarHandler(TERMINAL_CONTAINER_ID);
+  }
+
   private async _createClientOrIgnore(widget: IWidget) {
     if (this._clients.has(widget.id)) {
       return this._clients.get(widget.id)!;
@@ -397,11 +399,9 @@ export class TerminalController extends WithEventBus implements ITerminalControl
   }
 
   initContextKey(dom: HTMLDivElement) {
-    if (!this.terminalContextKey) {
-      this.terminalContextKey = this.injector.get(TerminalContextKey, [dom]);
-      this.terminalContextKey.isTerminalFocused.set(this._focus);
-      this.terminalContextKey.isTerminalViewInitialized.set(true);
-    }
+    this.terminalContextKey = this.injector.get(TerminalContextKey, [dom]);
+    this.terminalContextKey.isTerminalFocused.set(this._focus);
+    this.terminalContextKey.isTerminalViewInitialized.set(true);
   }
 
   async firstInitialize() {
@@ -418,7 +418,6 @@ export class TerminalController extends WithEventBus implements ITerminalControl
       }),
     ]);
 
-    this._tabBarHandler = this.layoutService.getTabbarHandler(TERMINAL_CONTAINER_ID);
     this.themeBackground = this.terminalTheme.terminalTheme.background || '';
 
     this.addDispose(

package/src/browser/terminal.hover.manager.ts

@@ -14,10 +14,12 @@ export class TerminalHoverManagerService implements ITerminalHoverManagerService
   private hoverWidget: HTMLElement | undefined;
 
   private appendTerminalHoverOverlay() {
-    const overlayContainer = document.querySelector('#ide-overlay');
+    let overlayContainer = document.querySelector('#terminal-link-hover-overlay');
 
     if (!overlayContainer) {
-      throw new Error('ide-overlay is requried');
+      overlayContainer = document.createElement('div');
+      overlayContainer.id = 'terminal-link-hover-overlay';
+      document.body.appendChild(overlayContainer);
     }
 
     const overlay = document.createElement('div');
@@ -72,13 +74,11 @@ export class TerminalHoverManagerService implements ITerminalHoverManagerService
         this.hoverWidget.style.top = `${
           (viewportRange.start.y - 1) * cellDimensions.height + boundingClientRect.y - TIPS_OFFSET_Y
         }px`;
-
         let tooltipsLeft = viewportRange.start.x * cellDimensions.width + boundingClientRect.x + TIPS_OFFSET_X;
         // if the tooltip is too close to the right edge of the terminal, move it to the left
         if (tooltipsLeft + this.hoverWidget.clientWidth > boundingClientRect.x + boundingClientRect.width) {
           tooltipsLeft = boundingClientRect.x + boundingClientRect.width - this.hoverWidget.clientWidth - TIPS_OFFSET_X;
         }
-
         this.hoverWidget.style.left = `${tooltipsLeft}px`;
       }
     });

package/src/browser/terminal.search.ts

@@ -1,11 +1,24 @@
 import { Autowired, Injectable } from '@opensumi/di';
 import { Emitter, Event, debounce } from '@opensumi/ide-core-common';
 
-import { ITerminalClient, ITerminalController, ITerminalGroupViewService, ITerminalSearchService } from '../common';
+import {
+  ITerminalClient,
+  ITerminalController,
+  ITerminalGroupViewService,
+  ITerminalSearchService,
+  IUIState,
+} from '../common';
 
 @Injectable()
 export class TerminalSearchService implements ITerminalSearchService {
   protected _isVisible: boolean = false;
+
+  public UIState: IUIState = {
+    isMatchCase: false,
+    isUseRegexp: false,
+    isWholeWord: false,
+  };
+
   get isVisible() {
     return this._isVisible;
   }
@@ -31,6 +44,10 @@ export class TerminalSearchService implements ITerminalSearchService {
     this.isVisible = true;
   }
 
+  get onResultChange() {
+    return this.client?.onSearchResultsChange;
+  }
+
   close() {
     this.client?.closeSearch();
     this.isVisible = false;
@@ -45,6 +62,36 @@ export class TerminalSearchService implements ITerminalSearchService {
 
   @debounce(150)
   search() {
-    this.client?.findNext(this.text);
+    this.client?.findNext(this.text, {
+      wholeWord: this.UIState.isWholeWord,
+      regex: this.UIState.isUseRegexp,
+      caseSensitive: this.UIState.isMatchCase,
+    });
+  }
+
+  @debounce(150)
+  searchPrevious() {
+    this.client?.findPrevious(this.text, {
+      wholeWord: this.UIState.isWholeWord,
+      regex: this.UIState.isUseRegexp,
+      caseSensitive: this.UIState.isMatchCase,
+    });
+  }
+
+  @debounce(150)
+  searchNext(): void {
+    this.client?.findNext(this.text, {
+      wholeWord: this.UIState.isWholeWord,
+      regex: this.UIState.isUseRegexp,
+      caseSensitive: this.UIState.isMatchCase,
+    });
+  }
+
+  updateUIState(state: Partial<IUIState>): void {
+    this.UIState = {
+      ...this.UIState,
+      ...state,
+    };
+    this.search();
   }
 }

package/src/browser/terminal.view.ts

@@ -275,6 +275,23 @@ export class TerminalGroupViewService implements ITerminalGroupViewService {
     return this.groups.get()[index];
   }
 
+  swapGroup(i: number, j: number) {
+    const groups = this.groups.get();
+
+    if (i === -1 || j === -1) {
+      return;
+    }
+
+    const newGroups = [...groups];
+    const temp = newGroups[i];
+    newGroups[i] = newGroups[j];
+    newGroups[j] = temp;
+
+    transaction((tx) => {
+      this.groups.set(newGroups, tx);
+    });
+  }
+
   private _doSelectGroup(index: number) {
     const group = this.getGroup(index);
     transaction((tx) => {

package/src/browser/xterm.ts

@@ -177,13 +177,26 @@ export class XTerm extends Disposable implements IXTerm {
     };
   }
 
-  findNext(text: string) {
+  findNext(text: string, searchOptions: ISearchOptions = {}) {
     const options: ISearchOptions = {
       decorations: this.getFindColors(),
+      ...searchOptions,
     };
     return this._searchAddon.findNext(text, options);
   }
 
+  findPrevious(text: string, searchOptions: ISearchOptions = {}) {
+    const options: ISearchOptions = {
+      decorations: this.getFindColors(),
+      ...searchOptions,
+    };
+    return this._searchAddon.findPrevious(text, options);
+  }
+
+  get onSearchResultsChange() {
+    return this._searchAddon.onDidChangeResults;
+  }
+
   closeSearch() {
     this._searchAddon.clearDecorations();
   }

package/src/common/client.ts

@@ -1,4 +1,5 @@
-import { Terminal } from '@xterm/xterm';
+import { ISearchOptions } from '@xterm/addon-search';
+import { IEvent, Terminal } from '@xterm/xterm';
 
 import { Deferred, Disposable, Event, IDisposable } from '@opensumi/ide-core-common';
 
@@ -116,7 +117,11 @@ export interface ITerminalClient extends Disposable {
    *
    * @param text 用户输入的字符串
    */
-  findNext(text: string): void;
+  findNext(text: string, searchOptions?: ISearchOptions): void;
+
+  findPrevious(text: string, searchOptions?: ISearchOptions): void;
+
+  onSearchResultsChange: IEvent<{ resultIndex: number; resultCount: number }>;
 
   closeSearch(): void;
 

package/src/common/controller.ts

@@ -1,3 +1,5 @@
+import { IEvent } from '@xterm/xterm';
+
 import { IContextKeyService } from '@opensumi/ide-core-browser';
 import { Deferred, Disposable, Event, IDisposable, Uri } from '@opensumi/ide-core-common';
 import { IObservable } from '@opensumi/ide-monaco/lib/common/observable';
@@ -113,10 +115,23 @@ export interface ITerminalController extends Disposable {
   registerLinkProvider(provider: ITerminalExternalLinkProvider): IDisposable;
 }
 
+export interface IUIState {
+  isMatchCase: boolean;
+  isWholeWord: boolean;
+  isUseRegexp: boolean;
+}
+
+export interface ISearchResult {
+  resultCount: number;
+  resultIndex: number;
+}
+
 export const ITerminalSearchService = Symbol('ITerminalSearchService');
 export interface ITerminalSearchService {
   isVisible: boolean;
   onVisibleChange: Event<boolean>;
+  UIState: IUIState;
+  onResultChange: IEvent<ISearchResult> | undefined;
 
   text: string;
 
@@ -124,6 +139,9 @@ export interface ITerminalSearchService {
   clear(): void;
   close(): void;
   search(): void;
+  searchNext(): void;
+  searchPrevious(): void;
+  updateUIState(state: Partial<IUIState>): void;
 }
 
 export const ITerminalGroupViewService = Symbol('ITerminalGroupViewService');
@@ -140,6 +158,8 @@ export interface ITerminalGroupViewService {
   selectGroup(index: number): void;
   removeGroup(index: number): void;
 
+  swapGroup(i: number, j: number): void;
+
   createWidget(group: IWidgetGroup, id?: string, reuse?: boolean, isSimpleWidget?: boolean): IWidget;
   getWidget(id: string): IWidget;
   selectWidget(widgetId: string): void;

package/src/common/pty.ts

@@ -539,7 +539,7 @@ export interface IShellLaunchConfig {
   /**
    * The color ID to use for this terminal. If not specified it will use the default fallback
    */
-  color?: vscode.ThemeColor;
+  color?: string | vscode.ThemeColor;
 
   /**
    * When a parent terminal is provided via API, the group needs

package/src/common/render.ts

@@ -18,8 +18,11 @@ export interface ItemProps {
   onDropdown?: (event: React.MouseEvent<HTMLElement>) => void;
   onContextMenu?: (event: React.MouseEvent<HTMLElement>) => void;
   getKeybinding?: (command: string) => string;
+  onDrop?: (event: React.DragEvent) => void;
+  onDragStart?: (event: React.DragEvent) => void;
   provider: ITerminalRenderProvider;
   theme: ThemeType;
+  draggable?: boolean;
 }
 
 export const ITerminalRenderProvider = Symbol('TerminalRenderProvider');