@xterm/xterm 5.6.0-beta.8 → 5.6.0-beta.80

package/src/common/services/CoreService.ts

@@ -4,10 +4,10 @@
  */
 
 import { clone } from 'common/Clone';
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { IDecPrivateModes, IModes } from 'common/Types';
 import { IBufferService, ICoreService, ILogService, IOptionsService } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 const DEFAULT_MODES: IModes = Object.freeze({
   insertMode: false
@@ -17,6 +17,8 @@ const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   applicationCursorKeys: false,
   applicationKeypad: false,
   bracketedPasteMode: false,
+  cursorBlink: undefined,
+  cursorStyle: undefined,
   origin: false,
   reverseWraparound: false,
   sendFocus: false,
@@ -31,13 +33,13 @@ export class CoreService extends Disposable implements ICoreService {
   public modes: IModes;
   public decPrivateModes: IDecPrivateModes;
 
-  private readonly _onData = this.register(new EventEmitter<string>());
+  private readonly _onData = this._register(new Emitter<string>());
   public readonly onData = this._onData.event;
-  private readonly _onUserInput = this.register(new EventEmitter<void>());
+  private readonly _onUserInput = this._register(new Emitter<void>());
   public readonly onUserInput = this._onUserInput.event;
-  private readonly _onBinary = this.register(new EventEmitter<string>());
+  private readonly _onBinary = this._register(new Emitter<string>());
   public readonly onBinary = this._onBinary.event;
-  private readonly _onRequestScrollToBottom = this.register(new EventEmitter<void>());
+  private readonly _onRequestScrollToBottom = this._register(new Emitter<void>());
   public readonly onRequestScrollToBottom = this._onRequestScrollToBottom.event;
 
   constructor(

package/src/common/services/DecorationService.ts

@@ -4,12 +4,12 @@
  */
 
 import { css } from 'common/Color';
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle';
 import { IDecorationService, IInternalDecoration } from 'common/services/Services';
 import { SortedList } from 'common/SortedList';
 import { IColor } from 'common/Types';
 import { IDecoration, IDecorationOptions, IMarker } from '@xterm/xterm';
+import { Emitter } from 'vs/base/common/event';
 
 // Work variables to avoid garbage collection
 let $xmin = 0;
@@ -25,9 +25,9 @@ export class DecorationService extends Disposable implements IDecorationService
    */
   private readonly _decorations: SortedList<IInternalDecoration> = new SortedList(e => e?.marker.line);
 
-  private readonly _onDecorationRegistered = this.register(new EventEmitter<IInternalDecoration>());
+  private readonly _onDecorationRegistered = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRegistered = this._onDecorationRegistered.event;
-  private readonly _onDecorationRemoved = this.register(new EventEmitter<IInternalDecoration>());
+  private readonly _onDecorationRemoved = this._register(new Emitter<IInternalDecoration>());
   public readonly onDecorationRemoved = this._onDecorationRemoved.event;
 
   public get decorations(): IterableIterator<IInternalDecoration> { return this._decorations.values(); }
@@ -35,7 +35,7 @@ export class DecorationService extends Disposable implements IDecorationService
   constructor() {
     super();
 
-    this.register(toDisposable(() => this.reset()));
+    this._register(toDisposable(() => this.reset()));
   }
 
   public registerDecoration(options: IDecorationOptions): IDecoration | undefined {
@@ -90,14 +90,13 @@ export class DecorationService extends Disposable implements IDecorationService
   }
 }
 
-class Decoration extends Disposable implements IInternalDecoration {
+class Decoration extends DisposableStore implements IInternalDecoration {
   public readonly marker: IMarker;
   public element: HTMLElement | undefined;
-  public get isDisposed(): boolean { return this._isDisposed; }
 
-  public readonly onRenderEmitter = this.register(new EventEmitter<HTMLElement>());
+  public readonly onRenderEmitter = this.add(new Emitter<HTMLElement>());
   public readonly onRender = this.onRenderEmitter.event;
-  private readonly _onDispose = this.register(new EventEmitter<void>());
+  private readonly _onDispose = this.add(new Emitter<void>());
   public readonly onDispose = this._onDispose.event;
 
   private _cachedBg: IColor | undefined | null = null;

package/src/common/services/InstantiationService.ts

@@ -67,7 +67,7 @@ export class InstantiationService implements IInstantiationService {
     for (const dependency of serviceDependencies) {
       const service = this._services.get(dependency.id);
       if (!service) {
-        throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`);
+        throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id._id}.`);
       }
       serviceArgs.push(service);
     }

package/src/common/services/LogService.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Disposable } from 'common/Lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 import { ILogService, IOptionsService, LogLevelEnum } from 'common/services/Services';
 
 type LogType = (message?: any, ...optionalParams: any[]) => void;
@@ -42,7 +42,7 @@ export class LogService extends Disposable implements ILogService {
   ) {
     super();
     this._updateLogLevel();
-    this.register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
+    this._register(this._optionsService.onSpecificOptionChange('logLevel', () => this._updateLogLevel()));
 
     // For trace logging, assume the latest created log service is valid
     traceLogger = this;

package/src/common/services/OptionsService.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
-import { Disposable, toDisposable } from 'common/Lifecycle';
+import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
 import { isMac } from 'common/Platform';
 import { CursorStyle, IDisposable } from 'common/Types';
 import { FontWeight, IOptionsService, ITerminalOptions } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   cols: 80,
@@ -44,6 +44,7 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   allowTransparency: false,
   tabStopWidth: 8,
   theme: {},
+  reflowCursorLine: false,
   rescaleOverlappingGlyphs: false,
   rightClickSelectsWord: isMac,
   windowOptions: {},
@@ -54,7 +55,7 @@ export const DEFAULT_OPTIONS: Readonly<Required<ITerminalOptions>> = {
   convertEol: false,
   termName: 'xterm',
   cancelEvents: false,
-  overviewRulerWidth: 0
+  overviewRuler: {}
 };
 
 const FONT_WEIGHT_OPTIONS: Extract<FontWeight, string>[] = ['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900'];
@@ -65,7 +66,7 @@ export class OptionsService extends Disposable implements IOptionsService {
   public readonly rawOptions: Required<ITerminalOptions>;
   public options: Required<ITerminalOptions>;
 
-  private readonly _onOptionChange = this.register(new EventEmitter<keyof ITerminalOptions>());
+  private readonly _onOptionChange = this._register(new Emitter<keyof ITerminalOptions>());
   public readonly onOptionChange = this._onOptionChange.event;
 
   constructor(options: Partial<ITerminalOptions>) {
@@ -90,7 +91,7 @@ export class OptionsService extends Disposable implements IOptionsService {
 
     // Clear out options that could link outside xterm.js as they could easily cause an embedder
     // memory leak
-    this.register(toDisposable(() => {
+    this._register(toDisposable(() => {
       this.rawOptions.linkHandler = null;
       this.rawOptions.documentOverride = null;
     }));

package/src/common/services/ServiceRegistry.ts

@@ -33,7 +33,7 @@ export function createDecorator<T>(id: string): IServiceIdentifier<T> {
     storeServiceDependency(decorator, target, index);
   };
 
-  decorator.toString = () => id;
+  decorator._id = id;
 
   serviceRegistry.set(id, decorator);
   return decorator;

package/src/common/services/Services.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-import { IEvent, IEventEmitter } from 'common/EventEmitter';
+import { IDecoration, IDecorationOptions, ILinkHandler, ILogger, IWindowsPty, type IOverviewRulerOptions } from '@xterm/xterm';
+import { CoreMouseEncoding, CoreMouseEventType, CursorInactiveStyle, CursorStyle, IAttributeData, ICharset, IColor, ICoreMouseEvent, ICoreMouseProtocol, IDecPrivateModes, IDisposable, IModes, IOscLinkData, IWindowOptions } from 'common/Types';
 import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IDecPrivateModes, ICoreMouseEvent, CoreMouseEncoding, ICoreMouseProtocol, CoreMouseEventType, ICharset, IWindowOptions, IModes, IAttributeData, ScrollSource, IDisposable, IColor, CursorStyle, CursorInactiveStyle, IOscLinkData } from 'common/Types';
 import { createDecorator } from 'common/services/ServiceRegistry';
-import { IDecorationOptions, IDecoration, ILinkHandler, IWindowsPty, ILogger } from '@xterm/xterm';
+import type { Emitter, Event } from 'vs/base/common/event';
 
 export const IBufferService = createDecorator<IBufferService>('BufferService');
 export interface IBufferService {
@@ -18,16 +18,18 @@ export interface IBufferService {
   readonly buffer: IBuffer;
   readonly buffers: IBufferSet;
   isUserScrolling: boolean;
-  onResize: IEvent<{ cols: number, rows: number }>;
-  onScroll: IEvent<number>;
+  onResize: Event<{ cols: number, rows: number }>;
+  onScroll: Event<number>;
   scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void;
-  scrollLines(disp: number, suppressScrollEvent?: boolean, source?: ScrollSource): void;
+  scrollLines(disp: number, suppressScrollEvent?: boolean): void;
   resize(cols: number, rows: number): void;
   reset(): void;
 }
 
 export const ICoreMouseService = createDecorator<ICoreMouseService>('CoreMouseService');
 export interface ICoreMouseService {
+  serviceBrand: undefined;
+
   activeProtocol: string;
   activeEncoding: string;
   areMouseEventsActive: boolean;
@@ -50,7 +52,7 @@ export interface ICoreMouseService {
   /**
    * Event to announce changes in mouse tracking.
    */
-  onProtocolChange: IEvent<CoreMouseEventType>;
+  onProtocolChange: Event<CoreMouseEventType>;
 
   /**
    * Human readable version of mouse events.
@@ -72,10 +74,10 @@ export interface ICoreService {
   readonly modes: IModes;
   readonly decPrivateModes: IDecPrivateModes;
 
-  readonly onData: IEvent<string>;
-  readonly onUserInput: IEvent<void>;
-  readonly onBinary: IEvent<string>;
-  readonly onRequestScrollToBottom: IEvent<void>;
+  readonly onData: Event<string>;
+  readonly onUserInput: Event<void>;
+  readonly onBinary: Event<string>;
+  readonly onRequestScrollToBottom: Event<void>;
 
   reset(): void;
 
@@ -122,6 +124,7 @@ export interface ICharsetService {
 export interface IServiceIdentifier<T> {
   (...args: any[]): void;
   type: T;
+  _id: string;
 }
 
 export interface IBrandedService {
@@ -184,7 +187,7 @@ export interface IOptionsService {
   /**
    * Adds an event listener for when any option changes.
    */
-  readonly onOptionChange: IEvent<keyof ITerminalOptions>;
+  readonly onOptionChange: Event<keyof ITerminalOptions>;
 
   /**
    * Adds an event listener for when a specific option changes, this is a convenience method that is
@@ -219,6 +222,7 @@ export interface ITerminalOptions {
   disableStdin?: boolean;
   documentOverride?: any | null;
   drawBoldTextInBrightColors?: boolean;
+  /** @deprecated No longer supported */
   fastScrollModifier?: 'none' | 'alt' | 'ctrl' | 'shift';
   fastScrollSensitivity?: number;
   fontSize?: number;
@@ -234,6 +238,7 @@ export interface ITerminalOptions {
   macOptionIsMeta?: boolean;
   macOptionClickForcesSelection?: boolean;
   minimumContrastRatio?: number;
+  reflowCursorLine?: boolean;
   rescaleOverlappingGlyphs?: boolean;
   rightClickSelectsWord?: boolean;
   rows?: number;
@@ -248,7 +253,7 @@ export interface ITerminalOptions {
   windowsPty?: IWindowsPty;
   windowOptions?: IWindowOptions;
   wordSeparator?: string;
-  overviewRulerWidth?: number;
+  overviewRuler?: IOverviewRulerOptions;
 
   [key: string]: any;
   cancelEvents: boolean;
@@ -263,6 +268,10 @@ export interface ITheme {
   selectionForeground?: string;
   selectionBackground?: string;
   selectionInactiveBackground?: string;
+  scrollbarSliderBackground?: string;
+  scrollbarSliderHoverBackground?: string;
+  scrollbarSliderActiveBackground?: string;
+  overviewRulerBorder?: string;
   black?: string;
   red?: string;
   green?: string;
@@ -331,7 +340,7 @@ export interface IUnicodeService {
   /** Currently active version. */
   activeVersion: string;
   /** Event triggered, when activate version changed. */
-  readonly onChange: IEvent<string>;
+  readonly onChange: Event<string>;
 
   /**
    * Unicode version dependent
@@ -356,8 +365,8 @@ export const IDecorationService = createDecorator<IDecorationService>('Decoratio
 export interface IDecorationService extends IDisposable {
   serviceBrand: undefined;
   readonly decorations: IterableIterator<IInternalDecoration>;
-  readonly onDecorationRegistered: IEvent<IInternalDecoration>;
-  readonly onDecorationRemoved: IEvent<IInternalDecoration>;
+  readonly onDecorationRegistered: Event<IInternalDecoration>;
+  readonly onDecorationRemoved: Event<IInternalDecoration>;
   registerDecoration(decorationOptions: IDecorationOptions): IDecoration | undefined;
   reset(): void;
   /**
@@ -370,5 +379,5 @@ export interface IInternalDecoration extends IDecoration {
   readonly options: IDecorationOptions;
   readonly backgroundColorRGB: IColor | undefined;
   readonly foregroundColorRGB: IColor | undefined;
-  readonly onRenderEmitter: IEventEmitter<HTMLElement>;
+  readonly onRenderEmitter: Emitter<HTMLElement>;
 }

package/src/common/services/UnicodeService.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 
-import { EventEmitter } from 'common/EventEmitter';
 import { UnicodeV6 } from 'common/input/UnicodeV6';
 import { IUnicodeService, IUnicodeVersionProvider, UnicodeCharProperties, UnicodeCharWidth } from 'common/services/Services';
+import { Emitter } from 'vs/base/common/event';
 
 export class UnicodeService implements IUnicodeService {
   public serviceBrand: any;
@@ -14,7 +14,7 @@ export class UnicodeService implements IUnicodeService {
   private _active: string = '';
   private _activeProvider: IUnicodeVersionProvider;
 
-  private readonly _onChange = new EventEmitter<string>();
+  private readonly _onChange = new Emitter<string>();
   public readonly onChange = this._onChange.event;
 
   public static extractShouldJoin(value: UnicodeCharProperties): boolean {

package/src/vs/base/browser/browser.ts

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CodeWindow, mainWindow } from 'vs/base/browser/window';
+import { Emitter } from 'vs/base/common/event';
+
+class WindowManager {
+
+	static readonly INSTANCE = new WindowManager();
+
+	// --- Zoom Level
+
+	private readonly mapWindowIdToZoomLevel = new Map<number, number>();
+
+	private readonly _onDidChangeZoomLevel = new Emitter<number>();
+	readonly onDidChangeZoomLevel = this._onDidChangeZoomLevel.event;
+
+	getZoomLevel(targetWindow: Window): number {
+		return this.mapWindowIdToZoomLevel.get(this.getWindowId(targetWindow)) ?? 0;
+	}
+	setZoomLevel(zoomLevel: number, targetWindow: Window): void {
+		if (this.getZoomLevel(targetWindow) === zoomLevel) {
+			return;
+		}
+
+		const targetWindowId = this.getWindowId(targetWindow);
+		this.mapWindowIdToZoomLevel.set(targetWindowId, zoomLevel);
+		this._onDidChangeZoomLevel.fire(targetWindowId);
+	}
+
+	// --- Zoom Factor
+
+	private readonly mapWindowIdToZoomFactor = new Map<number, number>();
+
+	getZoomFactor(targetWindow: Window): number {
+		return this.mapWindowIdToZoomFactor.get(this.getWindowId(targetWindow)) ?? 1;
+	}
+	setZoomFactor(zoomFactor: number, targetWindow: Window): void {
+		this.mapWindowIdToZoomFactor.set(this.getWindowId(targetWindow), zoomFactor);
+	}
+
+	// --- Fullscreen
+
+	private readonly _onDidChangeFullscreen = new Emitter<number>();
+	readonly onDidChangeFullscreen = this._onDidChangeFullscreen.event;
+
+	private readonly mapWindowIdToFullScreen = new Map<number, boolean>();
+
+	setFullscreen(fullscreen: boolean, targetWindow: Window): void {
+		if (this.isFullscreen(targetWindow) === fullscreen) {
+			return;
+		}
+
+		const windowId = this.getWindowId(targetWindow);
+		this.mapWindowIdToFullScreen.set(windowId, fullscreen);
+		this._onDidChangeFullscreen.fire(windowId);
+	}
+	isFullscreen(targetWindow: Window): boolean {
+		return !!this.mapWindowIdToFullScreen.get(this.getWindowId(targetWindow));
+	}
+
+	private getWindowId(targetWindow: Window): number {
+		return (targetWindow as CodeWindow).vscodeWindowId;
+	}
+}
+
+export function addMatchMediaChangeListener(targetWindow: Window, query: string | MediaQueryList, callback: (this: MediaQueryList, ev: MediaQueryListEvent) => any): void {
+	if (typeof query === 'string') {
+		query = targetWindow.matchMedia(query);
+	}
+	query.addEventListener('change', callback);
+}
+
+/** A zoom index, e.g. 1, 2, 3 */
+export function setZoomLevel(zoomLevel: number, targetWindow: Window): void {
+	WindowManager.INSTANCE.setZoomLevel(zoomLevel, targetWindow);
+}
+export function getZoomLevel(targetWindow: Window): number {
+	return WindowManager.INSTANCE.getZoomLevel(targetWindow);
+}
+export const onDidChangeZoomLevel = WindowManager.INSTANCE.onDidChangeZoomLevel;
+
+/** The zoom scale for an index, e.g. 1, 1.2, 1.4 */
+export function getZoomFactor(targetWindow: Window): number {
+	return WindowManager.INSTANCE.getZoomFactor(targetWindow);
+}
+export function setZoomFactor(zoomFactor: number, targetWindow: Window): void {
+	WindowManager.INSTANCE.setZoomFactor(zoomFactor, targetWindow);
+}
+
+export function setFullscreen(fullscreen: boolean, targetWindow: Window): void {
+	WindowManager.INSTANCE.setFullscreen(fullscreen, targetWindow);
+}
+export function isFullscreen(targetWindow: Window): boolean {
+	return WindowManager.INSTANCE.isFullscreen(targetWindow);
+}
+export const onDidChangeFullscreen = WindowManager.INSTANCE.onDidChangeFullscreen;
+
+const userAgent = typeof navigator === 'object' ? navigator.userAgent : '';
+
+export const isFirefox = (userAgent.indexOf('Firefox') >= 0);
+export const isWebKit = (userAgent.indexOf('AppleWebKit') >= 0);
+export const isChrome = (userAgent.indexOf('Chrome') >= 0);
+export const isSafari = (!isChrome && (userAgent.indexOf('Safari') >= 0));
+export const isWebkitWebView = (!isChrome && !isSafari && isWebKit);
+export const isElectron = (userAgent.indexOf('Electron/') >= 0);
+export const isAndroid = (userAgent.indexOf('Android') >= 0);
+
+let standalone = false;
+if (typeof mainWindow.matchMedia === 'function') {
+	const standaloneMatchMedia = mainWindow.matchMedia('(display-mode: standalone) or (display-mode: window-controls-overlay)');
+	const fullScreenMatchMedia = mainWindow.matchMedia('(display-mode: fullscreen)');
+	standalone = standaloneMatchMedia.matches;
+	addMatchMediaChangeListener(mainWindow, standaloneMatchMedia, ({ matches }) => {
+		// entering fullscreen would change standaloneMatchMedia.matches to false
+		// if standalone is true (running as PWA) and entering fullscreen, skip this change
+		if (standalone && fullScreenMatchMedia.matches) {
+			return;
+		}
+		// otherwise update standalone (browser to PWA or PWA to browser)
+		standalone = matches;
+	});
+}
+export function isStandalone(): boolean {
+	return standalone;
+}
+
+// Visible means that the feature is enabled, not necessarily being rendered
+// e.g. visible is true even in fullscreen mode where the controls are hidden
+// See docs at https://developer.mozilla.org/en-US/docs/Web/API/WindowControlsOverlay/visible
+export function isWCOEnabled(): boolean {
+	return (navigator as any)?.windowControlsOverlay?.visible;
+}
+
+// Returns the bounding rect of the titlebar area if it is supported and defined
+// See docs at https://developer.mozilla.org/en-US/docs/Web/API/WindowControlsOverlay/getTitlebarAreaRect
+export function getWCOBoundingRect(): DOMRect | undefined {
+	return (navigator as any)?.windowControlsOverlay?.getTitlebarAreaRect();
+}

package/src/vs/base/browser/canIUse.ts

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as browser from 'vs/base/browser/browser';
+import { mainWindow } from 'vs/base/browser/window';
+import * as platform from 'vs/base/common/platform';
+
+export const enum KeyboardSupport {
+	Always,
+	FullScreen,
+	None
+}
+
+const safeNavigator = typeof navigator === 'object' ? navigator : {} as { [key: string]: any };
+
+/**
+ * Browser feature we can support in current platform, browser and environment.
+ */
+export const BrowserFeatures = {
+	clipboard: {
+		writeText: (
+			platform.isNative
+			|| (document.queryCommandSupported && document.queryCommandSupported('copy'))
+			|| !!(safeNavigator && safeNavigator.clipboard && safeNavigator.clipboard.writeText)
+		),
+		readText: (
+			platform.isNative
+			|| !!(safeNavigator && safeNavigator.clipboard && safeNavigator.clipboard.readText)
+		)
+	},
+	keyboard: (() => {
+		if (platform.isNative || browser.isStandalone()) {
+			return KeyboardSupport.Always;
+		}
+
+		if ((<any>safeNavigator).keyboard || browser.isSafari) {
+			return KeyboardSupport.FullScreen;
+		}
+
+		return KeyboardSupport.None;
+	})(),
+
+	// 'ontouchstart' in window always evaluates to true with typescript's modern typings. This causes `window` to be
+	// `never` later in `window.navigator`. That's why we need the explicit `window as Window` cast
+	touch: 'ontouchstart' in mainWindow || safeNavigator.maxTouchPoints > 0,
+	pointerEvents: mainWindow.PointerEvent && ('ontouchstart' in mainWindow || navigator.maxTouchPoints > 0)
+};