@xterm/xterm 5.4.0-beta.1

package/src/browser/Linkifier2.ts

@@ -0,0 +1,416 @@
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { addDisposableDomListener } from 'browser/Lifecycle';
+import { IBufferCellPosition, ILink, ILinkDecorations, ILinkProvider, ILinkWithState, ILinkifier2, ILinkifierEvent } from 'browser/Types';
+import { EventEmitter } from 'common/EventEmitter';
+import { Disposable, disposeArray, getDisposeArrayDisposable, toDisposable } from 'common/Lifecycle';
+import { IDisposable } from 'common/Types';
+import { IBufferService } from 'common/services/Services';
+import { IMouseService, IRenderService } from './services/Services';
+
+export class Linkifier2 extends Disposable implements ILinkifier2 {
+  private _element: HTMLElement | undefined;
+  private _mouseService: IMouseService | undefined;
+  private _renderService: IRenderService | undefined;
+  private _linkProviders: ILinkProvider[] = [];
+  public get currentLink(): ILinkWithState | undefined { return this._currentLink; }
+  protected _currentLink: ILinkWithState | undefined;
+  private _mouseDownLink: ILinkWithState | undefined;
+  private _lastMouseEvent: MouseEvent | undefined;
+  private _linkCacheDisposables: IDisposable[] = [];
+  private _lastBufferCell: IBufferCellPosition | undefined;
+  private _isMouseOut: boolean = true;
+  private _wasResized: boolean = false;
+  private _activeProviderReplies: Map<Number, ILinkWithState[] | undefined> | undefined;
+  private _activeLine: number = -1;
+
+  private readonly _onShowLinkUnderline = this.register(new EventEmitter<ILinkifierEvent>());
+  public readonly onShowLinkUnderline = this._onShowLinkUnderline.event;
+  private readonly _onHideLinkUnderline = this.register(new EventEmitter<ILinkifierEvent>());
+  public readonly onHideLinkUnderline = this._onHideLinkUnderline.event;
+
+  constructor(
+    @IBufferService private readonly _bufferService: IBufferService
+  ) {
+    super();
+    this.register(getDisposeArrayDisposable(this._linkCacheDisposables));
+    this.register(toDisposable(() => {
+      this._lastMouseEvent = undefined;
+    }));
+    // Listen to resize to catch the case where it's resized and the cursor is out of the viewport.
+    this.register(this._bufferService.onResize(() => {
+      this._clearCurrentLink();
+      this._wasResized = true;
+    }));
+  }
+
+  public registerLinkProvider(linkProvider: ILinkProvider): IDisposable {
+    this._linkProviders.push(linkProvider);
+    return {
+      dispose: () => {
+        // Remove the link provider from the list
+        const providerIndex = this._linkProviders.indexOf(linkProvider);
+
+        if (providerIndex !== -1) {
+          this._linkProviders.splice(providerIndex, 1);
+        }
+      }
+    };
+  }
+
+  public attachToDom(element: HTMLElement, mouseService: IMouseService, renderService: IRenderService): void {
+    this._element = element;
+    this._mouseService = mouseService;
+    this._renderService = renderService;
+
+    this.register(addDisposableDomListener(this._element, 'mouseleave', () => {
+      this._isMouseOut = true;
+      this._clearCurrentLink();
+    }));
+    this.register(addDisposableDomListener(this._element, 'mousemove', this._handleMouseMove.bind(this)));
+    this.register(addDisposableDomListener(this._element, 'mousedown', this._handleMouseDown.bind(this)));
+    this.register(addDisposableDomListener(this._element, 'mouseup', this._handleMouseUp.bind(this)));
+  }
+
+  private _handleMouseMove(event: MouseEvent): void {
+    this._lastMouseEvent = event;
+
+    if (!this._element || !this._mouseService) {
+      return;
+    }
+
+    const position = this._positionFromMouseEvent(event, this._element, this._mouseService);
+    if (!position) {
+      return;
+    }
+    this._isMouseOut = false;
+
+    // Ignore the event if it's an embedder created hover widget
+    const composedPath = event.composedPath() as HTMLElement[];
+    for (let i = 0; i < composedPath.length; i++) {
+      const target = composedPath[i];
+      // Hit Terminal.element, break and continue
+      if (target.classList.contains('xterm')) {
+        break;
+      }
+      // It's a hover, don't respect hover event
+      if (target.classList.contains('xterm-hover')) {
+        return;
+      }
+    }
+
+    if (!this._lastBufferCell || (position.x !== this._lastBufferCell.x || position.y !== this._lastBufferCell.y)) {
+      this._handleHover(position);
+      this._lastBufferCell = position;
+    }
+  }
+
+  private _handleHover(position: IBufferCellPosition): void {
+    // TODO: This currently does not cache link provider results across wrapped lines, activeLine
+    //       should be something like `activeRange: {startY, endY}`
+    // Check if we need to clear the link
+    if (this._activeLine !== position.y || this._wasResized) {
+      this._clearCurrentLink();
+      this._askForLink(position, false);
+      this._wasResized = false;
+      return;
+    }
+
+    // Check the if the link is in the mouse position
+    const isCurrentLinkInPosition = this._currentLink && this._linkAtPosition(this._currentLink.link, position);
+    if (!isCurrentLinkInPosition) {
+      this._clearCurrentLink();
+      this._askForLink(position, true);
+    }
+  }
+
+  private _askForLink(position: IBufferCellPosition, useLineCache: boolean): void {
+    if (!this._activeProviderReplies || !useLineCache) {
+      this._activeProviderReplies?.forEach(reply => {
+        reply?.forEach(linkWithState => {
+          if (linkWithState.link.dispose) {
+            linkWithState.link.dispose();
+          }
+        });
+      });
+      this._activeProviderReplies = new Map();
+      this._activeLine = position.y;
+    }
+    let linkProvided = false;
+
+    // There is no link cached, so ask for one
+    for (const [i, linkProvider] of this._linkProviders.entries()) {
+      if (useLineCache) {
+        const existingReply = this._activeProviderReplies?.get(i);
+        // If there isn't a reply, the provider hasn't responded yet.
+
+        // TODO: If there isn't a reply yet it means that the provider is still resolving. Ensuring
+        // provideLinks isn't triggered again saves ILink.hover firing twice though. This probably
+        // needs promises to get fixed
+        if (existingReply) {
+          linkProvided = this._checkLinkProviderResult(i, position, linkProvided);
+        }
+      } else {
+        linkProvider.provideLinks(position.y, (links: ILink[] | undefined) => {
+          if (this._isMouseOut) {
+            return;
+          }
+          const linksWithState: ILinkWithState[] | undefined = links?.map(link  => ({ link }));
+          this._activeProviderReplies?.set(i, linksWithState);
+          linkProvided = this._checkLinkProviderResult(i, position, linkProvided);
+
+          // If all providers have responded, remove lower priority links that intersect ranges of
+          // higher priority links
+          if (this._activeProviderReplies?.size === this._linkProviders.length) {
+            this._removeIntersectingLinks(position.y, this._activeProviderReplies);
+          }
+        });
+      }
+    }
+  }
+
+  private _removeIntersectingLinks(y: number, replies: Map<Number, ILinkWithState[] | undefined>): void {
+    const occupiedCells = new Set<number>();
+    for (let i = 0; i < replies.size; i++) {
+      const providerReply = replies.get(i);
+      if (!providerReply) {
+        continue;
+      }
+      for (let i = 0; i < providerReply.length; i++) {
+        const linkWithState = providerReply[i];
+        const startX = linkWithState.link.range.start.y < y ? 0 : linkWithState.link.range.start.x;
+        const endX = linkWithState.link.range.end.y > y ? this._bufferService.cols : linkWithState.link.range.end.x;
+        for (let x = startX; x <= endX; x++) {
+          if (occupiedCells.has(x)) {
+            providerReply.splice(i--, 1);
+            break;
+          }
+          occupiedCells.add(x);
+        }
+      }
+    }
+  }
+
+  private _checkLinkProviderResult(index: number, position: IBufferCellPosition, linkProvided: boolean): boolean {
+    if (!this._activeProviderReplies) {
+      return linkProvided;
+    }
+
+    const links = this._activeProviderReplies.get(index);
+
+    // Check if every provider before this one has come back undefined
+    let hasLinkBefore = false;
+    for (let j = 0; j < index; j++) {
+      if (!this._activeProviderReplies.has(j) || this._activeProviderReplies.get(j)) {
+        hasLinkBefore = true;
+      }
+    }
+
+    // If all providers with higher priority came back undefined, then this provider's link for
+    // the position should be used
+    if (!hasLinkBefore && links) {
+      const linkAtPosition = links.find(link => this._linkAtPosition(link.link, position));
+      if (linkAtPosition) {
+        linkProvided = true;
+        this._handleNewLink(linkAtPosition);
+      }
+    }
+
+    // Check if all the providers have responded
+    if (this._activeProviderReplies.size === this._linkProviders.length && !linkProvided) {
+      // Respect the order of the link providers
+      for (let j = 0; j < this._activeProviderReplies.size; j++) {
+        const currentLink = this._activeProviderReplies.get(j)?.find(link => this._linkAtPosition(link.link, position));
+        if (currentLink) {
+          linkProvided = true;
+          this._handleNewLink(currentLink);
+          break;
+        }
+      }
+    }
+
+    return linkProvided;
+  }
+
+  private _handleMouseDown(): void {
+    this._mouseDownLink = this._currentLink;
+  }
+
+  private _handleMouseUp(event: MouseEvent): void {
+    if (!this._element || !this._mouseService || !this._currentLink) {
+      return;
+    }
+
+    const position = this._positionFromMouseEvent(event, this._element, this._mouseService);
+    if (!position) {
+      return;
+    }
+
+    if (this._mouseDownLink === this._currentLink && this._linkAtPosition(this._currentLink.link, position)) {
+      this._currentLink.link.activate(event, this._currentLink.link.text);
+    }
+  }
+
+  private _clearCurrentLink(startRow?: number, endRow?: number): void {
+    if (!this._element || !this._currentLink || !this._lastMouseEvent) {
+      return;
+    }
+
+    // If we have a start and end row, check that the link is within it
+    if (!startRow || !endRow || (this._currentLink.link.range.start.y >= startRow && this._currentLink.link.range.end.y <= endRow)) {
+      this._linkLeave(this._element, this._currentLink.link, this._lastMouseEvent);
+      this._currentLink = undefined;
+      disposeArray(this._linkCacheDisposables);
+    }
+  }
+
+  private _handleNewLink(linkWithState: ILinkWithState): void {
+    if (!this._element || !this._lastMouseEvent || !this._mouseService) {
+      return;
+    }
+
+    const position = this._positionFromMouseEvent(this._lastMouseEvent, this._element, this._mouseService);
+
+    if (!position) {
+      return;
+    }
+
+    // Trigger hover if the we have a link at the position
+    if (this._linkAtPosition(linkWithState.link, position)) {
+      this._currentLink = linkWithState;
+      this._currentLink.state = {
+        decorations: {
+          underline: linkWithState.link.decorations === undefined ? true : linkWithState.link.decorations.underline,
+          pointerCursor: linkWithState.link.decorations === undefined ? true : linkWithState.link.decorations.pointerCursor
+        },
+        isHovered: true
+      };
+      this._linkHover(this._element, linkWithState.link, this._lastMouseEvent);
+
+      // Add listener for tracking decorations changes
+      linkWithState.link.decorations = {} as ILinkDecorations;
+      Object.defineProperties(linkWithState.link.decorations, {
+        pointerCursor: {
+          get: () => this._currentLink?.state?.decorations.pointerCursor,
+          set: v => {
+            if (this._currentLink?.state && this._currentLink.state.decorations.pointerCursor !== v) {
+              this._currentLink.state.decorations.pointerCursor = v;
+              if (this._currentLink.state.isHovered) {
+                this._element?.classList.toggle('xterm-cursor-pointer', v);
+              }
+            }
+          }
+        },
+        underline: {
+          get: () => this._currentLink?.state?.decorations.underline,
+          set: v => {
+            if (this._currentLink?.state && this._currentLink?.state?.decorations.underline !== v) {
+              this._currentLink.state.decorations.underline = v;
+              if (this._currentLink.state.isHovered) {
+                this._fireUnderlineEvent(linkWithState.link, v);
+              }
+            }
+          }
+        }
+      });
+
+      // Listen to viewport changes to re-render the link under the cursor (only when the line the
+      // link is on changes)
+      if (this._renderService) {
+        this._linkCacheDisposables.push(this._renderService.onRenderedViewportChange(e => {
+          // Sanity check, this shouldn't happen in practice as this listener would be disposed
+          if (!this._currentLink) {
+            return;
+          }
+          // When start is 0 a scroll most likely occurred, make sure links above the fold also get
+          // cleared.
+          const start = e.start === 0 ? 0 : e.start + 1 + this._bufferService.buffer.ydisp;
+          const end = this._bufferService.buffer.ydisp + 1 + e.end;
+          // Only clear the link if the viewport change happened on this line
+          if (this._currentLink.link.range.start.y >= start && this._currentLink.link.range.end.y <= end) {
+            this._clearCurrentLink(start, end);
+            if (this._lastMouseEvent && this._element) {
+              // re-eval previously active link after changes
+              const position = this._positionFromMouseEvent(this._lastMouseEvent, this._element, this._mouseService!);
+              if (position) {
+                this._askForLink(position, false);
+              }
+            }
+          }
+        }));
+      }
+    }
+  }
+
+  protected _linkHover(element: HTMLElement, link: ILink, event: MouseEvent): void {
+    if (this._currentLink?.state) {
+      this._currentLink.state.isHovered = true;
+      if (this._currentLink.state.decorations.underline) {
+        this._fireUnderlineEvent(link, true);
+      }
+      if (this._currentLink.state.decorations.pointerCursor) {
+        element.classList.add('xterm-cursor-pointer');
+      }
+    }
+
+    if (link.hover) {
+      link.hover(event, link.text);
+    }
+  }
+
+  private _fireUnderlineEvent(link: ILink, showEvent: boolean): void {
+    const range = link.range;
+    const scrollOffset = this._bufferService.buffer.ydisp;
+    const event = this._createLinkUnderlineEvent(range.start.x - 1, range.start.y - scrollOffset - 1, range.end.x, range.end.y - scrollOffset - 1, undefined);
+    const emitter = showEvent ? this._onShowLinkUnderline : this._onHideLinkUnderline;
+    emitter.fire(event);
+  }
+
+  protected _linkLeave(element: HTMLElement, link: ILink, event: MouseEvent): void {
+    if (this._currentLink?.state) {
+      this._currentLink.state.isHovered = false;
+      if (this._currentLink.state.decorations.underline) {
+        this._fireUnderlineEvent(link, false);
+      }
+      if (this._currentLink.state.decorations.pointerCursor) {
+        element.classList.remove('xterm-cursor-pointer');
+      }
+    }
+
+    if (link.leave) {
+      link.leave(event, link.text);
+    }
+  }
+
+  /**
+   * Check if the buffer position is within the link
+   * @param link
+   * @param position
+   */
+  private _linkAtPosition(link: ILink, position: IBufferCellPosition): boolean {
+    const lower = link.range.start.y * this._bufferService.cols + link.range.start.x;
+    const upper = link.range.end.y * this._bufferService.cols + link.range.end.x;
+    const current = position.y * this._bufferService.cols + position.x;
+    return (lower <= current && current <= upper);
+  }
+
+  /**
+   * Get the buffer position from a mouse event
+   * @param event
+   */
+  private _positionFromMouseEvent(event: MouseEvent, element: HTMLElement, mouseService: IMouseService): IBufferCellPosition | undefined {
+    const coords = mouseService.getCoords(event, element, this._bufferService.cols, this._bufferService.rows);
+    if (!coords) {
+      return;
+    }
+
+    return { x: coords[0], y: coords[1] + this._bufferService.buffer.ydisp };
+  }
+
+  private _createLinkUnderlineEvent(x1: number, y1: number, x2: number, y2: number, fg: number | undefined): ILinkifierEvent {
+    return { x1, y1, x2, y2, cols: this._bufferService.cols, fg };
+  }
+}

package/src/browser/LocalizableStrings.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+// This file contains strings that get exported in the API so they can be localized
+
+// eslint-disable-next-line prefer-const
+export let promptLabel = 'Terminal input';
+
+// eslint-disable-next-line prefer-const
+export let tooMuchOutput = 'Too much output to announce, navigate to rows manually to read';

package/src/browser/OscLinkProvider.ts

@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) 2022 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IBufferRange, ILink, ILinkProvider } from 'browser/Types';
+import { CellData } from 'common/buffer/CellData';
+import { IBufferService, IOptionsService, IOscLinkService } from 'common/services/Services';
+
+export class OscLinkProvider implements ILinkProvider {
+  constructor(
+    @IBufferService private readonly _bufferService: IBufferService,
+    @IOptionsService private readonly _optionsService: IOptionsService,
+    @IOscLinkService private readonly _oscLinkService: IOscLinkService
+  ) {
+  }
+
+  public provideLinks(y: number, callback: (links: ILink[] | undefined) => void): void {
+    const line = this._bufferService.buffer.lines.get(y - 1);
+    if (!line) {
+      callback(undefined);
+      return;
+    }
+
+    const result: ILink[] = [];
+    const linkHandler = this._optionsService.rawOptions.linkHandler;
+    const cell = new CellData();
+    const lineLength = line.getTrimmedLength();
+    let currentLinkId = -1;
+    let currentStart = -1;
+    let finishLink = false;
+    for (let x = 0; x < lineLength; x++) {
+      // Minor optimization, only check for content if there isn't a link in case the link ends with
+      // a null cell
+      if (currentStart === -1 && !line.hasContent(x)) {
+        continue;
+      }
+
+      line.loadCell(x, cell);
+      if (cell.hasExtendedAttrs() && cell.extended.urlId) {
+        if (currentStart === -1) {
+          currentStart = x;
+          currentLinkId = cell.extended.urlId;
+          continue;
+        } else {
+          finishLink = cell.extended.urlId !== currentLinkId;
+        }
+      } else {
+        if (currentStart !== -1) {
+          finishLink = true;
+        }
+      }
+
+      if (finishLink || (currentStart !== -1 && x === lineLength - 1)) {
+        const text = this._oscLinkService.getLinkData(currentLinkId)?.uri;
+        if (text) {
+          // These ranges are 1-based
+          const range: IBufferRange = {
+            start: {
+              x: currentStart + 1,
+              y
+            },
+            end: {
+              // Offset end x if it's a link that ends on the last cell in the line
+              x: x + (!finishLink && x === lineLength - 1 ? 1 : 0),
+              y
+            }
+          };
+
+          let ignoreLink = false;
+          if (!linkHandler?.allowNonHttpProtocols) {
+            try {
+              const parsed = new URL(text);
+              if (!['http:', 'https:'].includes(parsed.protocol)) {
+                ignoreLink = true;
+              }
+            } catch (e) {
+              // Ignore invalid URLs to prevent unexpected behaviors
+              ignoreLink = true;
+            }
+          }
+
+          if (!ignoreLink) {
+            // OSC links always use underline and pointer decorations
+            result.push({
+              text,
+              range,
+              activate: (e, text) => (linkHandler ? linkHandler.activate(e, text, range) : defaultActivate(e, text)),
+              hover: (e, text) => linkHandler?.hover?.(e, text, range),
+              leave: (e, text) => linkHandler?.leave?.(e, text, range)
+            });
+          }
+        }
+        finishLink = false;
+
+        // Clear link or start a new link if one starts immediately
+        if (cell.hasExtendedAttrs() && cell.extended.urlId) {
+          currentStart = x;
+          currentLinkId = cell.extended.urlId;
+        } else {
+          currentStart = -1;
+          currentLinkId = -1;
+        }
+      }
+    }
+
+    // TODO: Handle fetching and returning other link ranges to underline other links with the same
+    //       id
+    callback(result);
+  }
+}
+
+function defaultActivate(e: MouseEvent, uri: string): void {
+  const answer = confirm(`Do you want to navigate to ${uri}?\n\nWARNING: This link could potentially be dangerous`);
+  if (answer) {
+    const newWindow = window.open();
+    if (newWindow) {
+      try {
+        newWindow.opener = null;
+      } catch {
+        // no-op, Electron can throw
+      }
+      newWindow.location.href = uri;
+    } else {
+      console.warn('Opening link blocked as opener could not be cleared');
+    }
+  }
+}

package/src/browser/RenderDebouncer.ts

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2018 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IRenderDebouncerWithCallback } from 'browser/Types';
+
+/**
+ * Debounces calls to render terminal rows using animation frames.
+ */
+export class RenderDebouncer implements IRenderDebouncerWithCallback {
+  private _rowStart: number | undefined;
+  private _rowEnd: number | undefined;
+  private _rowCount: number | undefined;
+  private _animationFrame: number | undefined;
+  private _refreshCallbacks: FrameRequestCallback[] = [];
+
+  constructor(
+    private _parentWindow: Window,
+    private _renderCallback: (start: number, end: number) => void
+  ) {
+  }
+
+  public dispose(): void {
+    if (this._animationFrame) {
+      this._parentWindow.cancelAnimationFrame(this._animationFrame);
+      this._animationFrame = undefined;
+    }
+  }
+
+  public addRefreshCallback(callback: FrameRequestCallback): number {
+    this._refreshCallbacks.push(callback);
+    if (!this._animationFrame) {
+      this._animationFrame = this._parentWindow.requestAnimationFrame(() => this._innerRefresh());
+    }
+    return this._animationFrame;
+  }
+
+  public refresh(rowStart: number | undefined, rowEnd: number | undefined, rowCount: number): void {
+    this._rowCount = rowCount;
+    // Get the min/max row start/end for the arg values
+    rowStart = rowStart !== undefined ? rowStart : 0;
+    rowEnd = rowEnd !== undefined ? rowEnd : this._rowCount - 1;
+    // Set the properties to the updated values
+    this._rowStart = this._rowStart !== undefined ? Math.min(this._rowStart, rowStart) : rowStart;
+    this._rowEnd = this._rowEnd !== undefined ? Math.max(this._rowEnd, rowEnd) : rowEnd;
+
+    if (this._animationFrame) {
+      return;
+    }
+
+    this._animationFrame = this._parentWindow.requestAnimationFrame(() => this._innerRefresh());
+  }
+
+  private _innerRefresh(): void {
+    this._animationFrame = undefined;
+
+    // Make sure values are set
+    if (this._rowStart === undefined || this._rowEnd === undefined || this._rowCount === undefined) {
+      this._runRefreshCallbacks();
+      return;
+    }
+
+    // Clamp values
+    const start = Math.max(this._rowStart, 0);
+    const end = Math.min(this._rowEnd, this._rowCount - 1);
+
+    // Reset debouncer (this happens before render callback as the render could trigger it again)
+    this._rowStart = undefined;
+    this._rowEnd = undefined;
+
+    // Run render callback
+    this._renderCallback(start, end);
+    this._runRefreshCallbacks();
+  }
+
+  private _runRefreshCallbacks(): void {
+    for (const callback of this._refreshCallbacks) {
+      callback(0);
+    }
+    this._refreshCallbacks = [];
+  }
+}