@xterm/xterm 5.6.0-beta.7 → 5.6.0-beta.70

package/src/browser/Linkifier.ts

@@ -3,13 +3,13 @@
  * @license MIT
  */
 
-import { addDisposableDomListener } from 'browser/Lifecycle';
 import { IBufferCellPosition, ILink, ILinkDecorations, ILinkWithState, ILinkifier2, ILinkifierEvent } from 'browser/Types';
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable, disposeArray, getDisposeArrayDisposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, dispose, toDisposable } from 'vs/base/common/lifecycle';
 import { IDisposable } from 'common/Types';
 import { IBufferService } from 'common/services/Services';
 import { ILinkProviderService, IMouseService, IRenderService } from './services/Services';
+import { Emitter } from 'vs/base/common/event';
+import { addDisposableListener } from 'vs/base/browser/dom';
 
 export class Linkifier extends Disposable implements ILinkifier2 {
   public get currentLink(): ILinkWithState | undefined { return this._currentLink; }
@@ -23,9 +23,9 @@ export class Linkifier extends Disposable implements ILinkifier2 {
   private _activeProviderReplies: Map<Number, ILinkWithState[] | undefined> | undefined;
   private _activeLine: number = -1;
 
-  private readonly _onShowLinkUnderline = this.register(new EventEmitter<ILinkifierEvent>());
+  private readonly _onShowLinkUnderline = this._register(new Emitter<ILinkifierEvent>());
   public readonly onShowLinkUnderline = this._onShowLinkUnderline.event;
-  private readonly _onHideLinkUnderline = this.register(new EventEmitter<ILinkifierEvent>());
+  private readonly _onHideLinkUnderline = this._register(new Emitter<ILinkifierEvent>());
   public readonly onHideLinkUnderline = this._onHideLinkUnderline.event;
 
   constructor(
@@ -36,24 +36,25 @@ export class Linkifier extends Disposable implements ILinkifier2 {
     @ILinkProviderService private readonly _linkProviderService: ILinkProviderService
   ) {
     super();
-    this.register(getDisposeArrayDisposable(this._linkCacheDisposables));
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
+      dispose(this._linkCacheDisposables);
+      this._linkCacheDisposables.length = 0;
       this._lastMouseEvent = undefined;
       // Clear out link providers as they could easily cause an embedder memory leak
       this._activeProviderReplies?.clear();
     }));
     // 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._register(this._bufferService.onResize(() => {
       this._clearCurrentLink();
       this._wasResized = true;
     }));
-    this.register(addDisposableDomListener(this._element, 'mouseleave', () => {
+    this._register(addDisposableListener(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)));
+    this._register(addDisposableListener(this._element, 'mousemove', this._handleMouseMove.bind(this)));
+    this._register(addDisposableListener(this._element, 'mousedown', this._handleMouseDown.bind(this)));
+    this._register(addDisposableListener(this._element, 'mouseup', this._handleMouseUp.bind(this)));
   }
 
   private _handleMouseMove(event: MouseEvent): void {
@@ -226,7 +227,7 @@ export class Linkifier extends Disposable implements ILinkifier2 {
       return;
     }
 
-    if (this._mouseDownLink === this._currentLink && this._linkAtPosition(this._currentLink.link, position)) {
+    if (this._mouseDownLink && linkEquals(this._mouseDownLink.link, this._currentLink.link) && this._linkAtPosition(this._currentLink.link, position)) {
       this._currentLink.link.activate(event, this._currentLink.link.text);
     }
   }
@@ -240,7 +241,8 @@ export class Linkifier extends Disposable implements ILinkifier2 {
     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);
+      dispose(this._linkCacheDisposables);
+      this._linkCacheDisposables.length = 0;
     }
   }
 
@@ -389,3 +391,13 @@ export class Linkifier extends Disposable implements ILinkifier2 {
     return { x1, y1, x2, y2, cols: this._bufferService.cols, fg };
   }
 }
+
+function linkEquals(a: ILink, b: ILink): boolean {
+  return (
+    a.text === b.text &&
+    a.range.start.x === b.range.start.x &&
+    a.range.start.y === b.range.start.y &&
+    a.range.end.x === b.range.end.x &&
+    a.range.end.y === b.range.end.y
+  );
+}

package/src/browser/LocalizableStrings.ts

@@ -5,8 +5,19 @@
 
 // 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';
+let promptLabelInternal = 'Terminal input';
+const promptLabel = {
+  get: () => promptLabelInternal,
+  set: (value: string) => promptLabelInternal = value
+};
 
-// eslint-disable-next-line prefer-const
-export let tooMuchOutput = 'Too much output to announce, navigate to rows manually to read';
+let tooMuchOutputInternal = 'Too much output to announce, navigate to rows manually to read';
+const tooMuchOutput = {
+  get: () => tooMuchOutputInternal,
+  set: (value: string) => tooMuchOutputInternal = value
+};
+
+export {
+  promptLabel,
+  tooMuchOutput
+};

package/src/browser/{Types.d.ts → Types.ts}

@@ -3,10 +3,11 @@
  * @license MIT
  */
 
-import { IEvent } from 'common/EventEmitter';
 import { CharData, IColor, ICoreTerminal, ITerminalOptions } from 'common/Types';
 import { IBuffer } from 'common/buffer/Types';
 import { IDisposable, Terminal as ITerminalApi } from '@xterm/xterm';
+import { channels, css } from 'common/Color';
+import type { Event } from 'vs/base/common/event';
 
 /**
  * A portion of the public API that are implemented identially internally and simply passed through.
@@ -18,16 +19,15 @@ export interface ITerminal extends InternalPassthroughApis, ICoreTerminal {
   browser: IBrowser;
   buffer: IBuffer;
   linkifier: ILinkifier2 | undefined;
-  viewport: IViewport | undefined;
   options: Required<ITerminalOptions>;
 
-  onBlur: IEvent<void>;
-  onFocus: IEvent<void>;
-  onA11yChar: IEvent<string>;
-  onA11yTab: IEvent<number>;
-  onWillOpen: IEvent<HTMLElement>;
+  onBlur: Event<void>;
+  onFocus: Event<void>;
+  onA11yChar: Event<string>;
+  onA11yTab: Event<number>;
+  onWillOpen: Event<HTMLElement>;
 
-  cancel(ev: Event, force?: boolean): boolean | void;
+  cancel(ev: MouseEvent | WheelEvent | KeyboardEvent | InputEvent, force?: boolean): boolean | void;
 }
 
 export type CustomKeyEventHandler = (event: KeyboardEvent) => boolean;
@@ -66,6 +66,10 @@ export interface IColorSet {
   selectionBackgroundOpaque: IColor;
   selectionInactiveBackgroundTransparent: IColor;
   selectionInactiveBackgroundOpaque: IColor;
+  scrollbarSliderBackground: IColor;
+  scrollbarSliderHoverBackground: IColor;
+  scrollbarSliderActiveBackground: IColor;
+  overviewRulerBorder: IColor;
   ansi: IColor[];
   /** Maps original colors to colors that respect minimum contrast ratio. */
   contrastCache: IColorContrastCache;
@@ -94,7 +98,7 @@ export interface IPartialColorSet {
 
 export interface IViewport extends IDisposable {
   scrollBarWidth: number;
-  readonly onRequestScrollLines: IEvent<{ amount: number, suppressScrollEvent: boolean }>;
+  readonly onRequestScrollLines: Event<{ amount: number, suppressScrollEvent: boolean }>;
   syncScrollArea(immediate?: boolean, force?: boolean): void;
   getLinesScrolled(ev: WheelEvent): number;
   getBufferElements(startLine: number, endLine?: number): { bufferElements: HTMLElement[], cursorElement?: HTMLElement };
@@ -124,12 +128,12 @@ export interface ILinkWithState {
 }
 
 export interface ILinkifier2 extends IDisposable {
-  onShowLinkUnderline: IEvent<ILinkifierEvent>;
-  onHideLinkUnderline: IEvent<ILinkifierEvent>;
+  onShowLinkUnderline: Event<ILinkifierEvent>;
+  onHideLinkUnderline: Event<ILinkifierEvent>;
   readonly currentLink: ILinkWithState | undefined;
 }
 
-interface ILink {
+export interface ILink {
   range: IBufferRange;
   text: string;
   decorations?: ILinkDecorations;
@@ -139,17 +143,17 @@ interface ILink {
   dispose?(): void;
 }
 
-interface ILinkDecorations {
+export interface ILinkDecorations {
   pointerCursor: boolean;
   underline: boolean;
 }
 
-interface IBufferRange {
+export interface IBufferRange {
   start: IBufferCellPosition;
   end: IBufferCellPosition;
 }
 
-interface IBufferCellPosition {
+export interface IBufferCellPosition {
   x: number;
   y: number;
 }
@@ -172,3 +176,51 @@ export interface IRenderDebouncerWithCallback extends IRenderDebouncer {
 export interface IBufferElementProvider {
   provideBufferElements(): DocumentFragment | HTMLElement;
 }
+
+// An IIFE to generate DEFAULT_ANSI_COLORS.
+export const DEFAULT_ANSI_COLORS = Object.freeze((() => {
+  const colors = [
+    // dark:
+    css.toColor('#2e3436'),
+    css.toColor('#cc0000'),
+    css.toColor('#4e9a06'),
+    css.toColor('#c4a000'),
+    css.toColor('#3465a4'),
+    css.toColor('#75507b'),
+    css.toColor('#06989a'),
+    css.toColor('#d3d7cf'),
+    // bright:
+    css.toColor('#555753'),
+    css.toColor('#ef2929'),
+    css.toColor('#8ae234'),
+    css.toColor('#fce94f'),
+    css.toColor('#729fcf'),
+    css.toColor('#ad7fa8'),
+    css.toColor('#34e2e2'),
+    css.toColor('#eeeeec')
+  ];
+
+  // Fill in the remaining 240 ANSI colors.
+  // Generate colors (16-231)
+  const v = [0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff];
+  for (let i = 0; i < 216; i++) {
+    const r = v[(i / 36) % 6 | 0];
+    const g = v[(i / 6) % 6 | 0];
+    const b = v[i % 6];
+    colors.push({
+      css: channels.toCss(r, g, b),
+      rgba: channels.toRgba(r, g, b)
+    });
+  }
+
+  // Generate greys (232-255)
+  for (let i = 0; i < 24; i++) {
+    const c = 8 + i * 10;
+    colors.push({
+      css: channels.toCss(c, c, c),
+      rgba: channels.toRgba(c, c, c)
+    });
+  }
+
+  return colors;
+})());