@xterm/xterm 6.1.0-beta.3 → 6.1.0-beta.300

package/src/common/services/OscLinkService.ts

@@ -2,8 +2,9 @@
  * Copyright (c) 2022 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IBufferService, IOscLinkService } from 'common/services/Services';
-import { IMarker, IOscLinkData } from 'common/Types';
+import { IBufferService, IOscLinkService } from './Services';
+import { IOscLinkData } from '../Types';
+import { IMarker } from '../buffer/Types';
 
 export class OscLinkService implements IOscLinkService {
   public serviceBrand: any;

package/src/common/services/ServiceRegistry.ts

@@ -9,15 +9,21 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { IServiceIdentifier } from 'common/services/Services';
+export interface IServiceIdentifier<T> {
+  (...args: any[]): void;
+  type: T;
+  _id: string;
+}
 
-const DI_TARGET = 'di$target';
-const DI_DEPENDENCIES = 'di$dependencies';
+const enum Constants {
+  DI_TARGET = 'di$target',
+  DI_DEPENDENCIES = 'di$dependencies'
+}
 
 export const serviceRegistry: Map<string, IServiceIdentifier<any>> = new Map();
 
 export function getServiceDependencies(ctor: any): { id: IServiceIdentifier<any>, index: number, optional: boolean }[] {
-  return ctor[DI_DEPENDENCIES] || [];
+  return ctor[Constants.DI_DEPENDENCIES] || [];
 }
 
 export function createDecorator<T>(id: string): IServiceIdentifier<T> {
@@ -40,10 +46,10 @@ export function createDecorator<T>(id: string): IServiceIdentifier<T> {
 }
 
 function storeServiceDependency(id: Function, target: Function, index: number): void {
-  if ((target as any)[DI_TARGET] === target) {
-    (target as any)[DI_DEPENDENCIES].push({ id, index });
+  if ((target as any)[Constants.DI_TARGET] === target) {
+    (target as any)[Constants.DI_DEPENDENCIES].push({ id, index });
   } else {
-    (target as any)[DI_DEPENDENCIES] = [{ id, index }];
-    (target as any)[DI_TARGET] = target;
+    (target as any)[Constants.DI_DEPENDENCIES] = [{ id, index }];
+    (target as any)[Constants.DI_TARGET] = target;
   }
 }

package/src/common/services/Services.ts

@@ -3,11 +3,11 @@
  * @license MIT
  */
 
-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 { createDecorator } from 'common/services/ServiceRegistry';
-import type { Emitter, Event } from 'vs/base/common/event';
+import type { IDecoration, IDecorationOptions, ILinkHandler, ILogger, IWindowsPty, IOverviewRulerOptions } from '@xterm/xterm';
+import { CoreMouseEncoding, CoreMouseEventType, CursorInactiveStyle, CursorStyle, ICharset, IColor, ICoreMouseEvent, ICoreMouseProtocol, IDecPrivateModes, IDisposable, IKittyKeyboardState, IModes, IOscLinkData, IWindowOptions } from '../Types';
+import { IAttributeData, IBuffer, IBufferSet } from '../buffer/Types';
+import { createDecorator, IServiceIdentifier } from './ServiceRegistry';
+import type { Emitter, IEvent } from '../Event';
 
 export const IBufferService = createDecorator<IBufferService>('BufferService');
 export interface IBufferService {
@@ -18,8 +18,8 @@ export interface IBufferService {
   readonly buffer: IBuffer;
   readonly buffers: IBufferSet;
   isUserScrolling: boolean;
-  onResize: Event<IBufferResizeEvent>;
-  onScroll: Event<number>;
+  onResize: IEvent<IBufferResizeEvent>;
+  onScroll: IEvent<number>;
   scroll(eraseAttr: IAttributeData, isWrapped?: boolean): void;
   scrollLines(disp: number, suppressScrollEvent?: boolean): void;
   resize(cols: number, rows: number): void;
@@ -33,8 +33,8 @@ export interface IBufferResizeEvent {
   rowsChanged: boolean;
 }
 
-export const ICoreMouseService = createDecorator<ICoreMouseService>('CoreMouseService');
-export interface ICoreMouseService {
+export const IMouseStateService = createDecorator<IMouseStateService>('MouseStateService');
+export interface IMouseStateService {
   serviceBrand: undefined;
 
   activeProtocol: string;
@@ -43,33 +43,17 @@ export interface ICoreMouseService {
   addProtocol(name: string, protocol: ICoreMouseProtocol): void;
   addEncoding(name: string, encoding: CoreMouseEncoding): void;
   reset(): void;
-
-  /**
-   * Triggers a mouse event to be sent.
-   *
-   * Returns true if the event passed all protocol restrictions and a report
-   * was sent, otherwise false. The return value may be used to decide whether
-   * the default event action in the bowser component should be omitted.
-   *
-   * Note: The method will change values of the given event object
-   * to fullfill protocol and encoding restrictions.
-   */
-  triggerMouseEvent(event: ICoreMouseEvent): boolean;
+  setCustomWheelEventHandler(customWheelEventHandler: ((event: WheelEvent) => boolean) | undefined): void;
+  allowCustomWheelEvent(ev: WheelEvent): boolean;
 
   /**
    * Event to announce changes in mouse tracking.
    */
-  onProtocolChange: Event<CoreMouseEventType>;
-
-  /**
-   * Human readable version of mouse events.
-   */
-  explainEvents(events: CoreMouseEventType): { [event: string]: boolean };
-
-  /**
-   * Process wheel event taking partial scroll into account.
-   */
-  consumeWheelEvent(ev: WheelEvent, cellHeight?: number, dpr?: number): number;
+  onProtocolChange: IEvent<CoreMouseEventType>;
+  restrictMouseEvent(event: ICoreMouseEvent): boolean;
+  encodeMouseEvent(event: ICoreMouseEvent): string;
+  readonly isDefaultEncoding: boolean;
+  readonly isPixelEncoding: boolean;
 }
 
 export const ICoreService = createDecorator<ICoreService>('CoreService');
@@ -85,11 +69,12 @@ export interface ICoreService {
 
   readonly modes: IModes;
   readonly decPrivateModes: IDecPrivateModes;
+  readonly kittyKeyboard: IKittyKeyboardState;
 
-  readonly onData: Event<string>;
-  readonly onUserInput: Event<void>;
-  readonly onBinary: Event<string>;
-  readonly onRequestScrollToBottom: Event<void>;
+  readonly onData: IEvent<string>;
+  readonly onUserInput: IEvent<void>;
+  readonly onBinary: IEvent<string>;
+  readonly onRequestScrollToBottom: IEvent<void>;
 
   reset(): void;
 
@@ -116,6 +101,7 @@ export interface ICharsetService {
 
   charset: ICharset | undefined;
   readonly glevel: number;
+  readonly charsets: (ICharset | undefined)[];
 
   reset(): void;
 
@@ -133,12 +119,6 @@ export interface ICharsetService {
   setgCharset(g: number, charset: ICharset | undefined): void;
 }
 
-export interface IServiceIdentifier<T> {
-  (...args: any[]): void;
-  type: T;
-  _id: string;
-}
-
 export interface IBrandedService {
   serviceBrand: undefined;
 }
@@ -199,7 +179,7 @@ export interface IOptionsService {
   /**
    * Adds an event listener for when any option changes.
    */
-  readonly onOptionChange: Event<keyof ITerminalOptions>;
+  readonly onOptionChange: IEvent<keyof ITerminalOptions>;
 
   /**
    * Adds an event listener for when a specific option changes, this is a convenience method that is
@@ -227,15 +207,13 @@ export interface ITerminalOptions {
   cols?: number;
   convertEol?: boolean;
   cursorBlink?: boolean;
+  blinkIntervalDuration?: number;
   cursorStyle?: CursorStyle;
   cursorWidth?: number;
   cursorInactiveStyle?: CursorInactiveStyle;
-  customGlyphs?: boolean;
   disableStdin?: boolean;
   documentOverride?: any | null;
   drawBoldTextInBrightColors?: boolean;
-  /** @deprecated No longer supported */
-  fastScrollModifier?: 'none' | 'alt' | 'ctrl' | 'shift';
   fastScrollSensitivity?: number;
   fontSize?: number;
   fontFamily?: string;
@@ -250,10 +228,12 @@ export interface ITerminalOptions {
   macOptionIsMeta?: boolean;
   macOptionClickForcesSelection?: boolean;
   minimumContrastRatio?: number;
+  mouseEventsRequireAlt?: boolean;
   reflowCursorLine?: boolean;
   rescaleOverlappingGlyphs?: boolean;
   rightClickSelectsWord?: boolean;
   rows?: number;
+  showCursorImmediately?: boolean;
   screenReaderMode?: boolean;
   scrollback?: number;
   scrollOnUserInput?: boolean;
@@ -261,15 +241,15 @@ export interface ITerminalOptions {
   smoothScrollDuration?: number;
   tabStopWidth?: number;
   theme?: ITheme;
-  windowsMode?: boolean;
   windowsPty?: IWindowsPty;
   windowOptions?: IWindowOptions;
   wordSeparator?: string;
-  overviewRuler?: IOverviewRulerOptions;
+  quirks?: ITerminalQuirks;
+  scrollbar?: IScrollbarOptions;
   scrollOnEraseInDisplay?: boolean;
+  vtExtensions?: IVtExtensions;
 
   [key: string]: any;
-  cancelEvents: boolean;
   termName: string;
 }
 
@@ -304,6 +284,24 @@ export interface ITheme {
   extendedAnsi?: string[];
 }
 
+export interface ITerminalQuirks {
+  allowSetCursorBlink?: boolean;
+}
+
+export interface IScrollbarOptions {
+  showScrollbar?: boolean;
+  showArrows?: boolean;
+  width?: number;
+  overviewRuler?: IOverviewRulerOptions;
+}
+
+export interface IVtExtensions {
+  kittyKeyboard?: boolean;
+  kittySgrBoldFaintControl?: boolean;
+  win32InputMode?: boolean;
+  colorSchemeQuery?: boolean;
+}
+
 export const IOscLinkService = createDecorator<IOscLinkService>('OscLinkService');
 export interface IOscLinkService {
   serviceBrand: undefined;
@@ -346,14 +344,14 @@ export type UnicodeCharWidth = 0 | 1 | 2;
 export const IUnicodeService = createDecorator<IUnicodeService>('UnicodeService');
 export interface IUnicodeService {
   serviceBrand: undefined;
-  /** Register an Unicode version provider. */
+  /** Register a Unicode version provider. */
   register(provider: IUnicodeVersionProvider): void;
   /** Registered Unicode versions. */
   readonly versions: string[];
   /** Currently active version. */
   activeVersion: string;
-  /** Event triggered, when activate version changed. */
-  readonly onChange: Event<string>;
+  /** Event triggered when the active version changes. */
+  readonly onChange: IEvent<string>;
 
   /**
    * Unicode version dependent
@@ -378,8 +376,8 @@ export const IDecorationService = createDecorator<IDecorationService>('Decoratio
 export interface IDecorationService extends IDisposable {
   serviceBrand: undefined;
   readonly decorations: IterableIterator<IInternalDecoration>;
-  readonly onDecorationRegistered: Event<IInternalDecoration>;
-  readonly onDecorationRemoved: Event<IInternalDecoration>;
+  readonly onDecorationRegistered: IEvent<IInternalDecoration>;
+  readonly onDecorationRemoved: IEvent<IInternalDecoration>;
   registerDecoration(decorationOptions: IDecorationOptions): IDecoration | undefined;
   reset(): void;
   /**
@@ -393,4 +391,6 @@ export interface IInternalDecoration extends IDecoration {
   readonly backgroundColorRGB: IColor | undefined;
   readonly foregroundColorRGB: IColor | undefined;
   readonly onRenderEmitter: Emitter<HTMLElement>;
+  /** @internal Start line for line-index removal; kept in sync on buffer line shifts. */
+  _indexedStartLine: number;
 }

package/src/common/services/UnicodeService.ts

@@ -3,16 +3,15 @@
  * @license MIT
  */
 
-import { UnicodeV6 } from 'common/input/UnicodeV6';
-import { IUnicodeService, IUnicodeVersionProvider, UnicodeCharProperties, UnicodeCharWidth } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
+import { IUnicodeService, IUnicodeVersionProvider, UnicodeCharProperties, UnicodeCharWidth } from './Services';
+import { Emitter } from '../Event';
 
 export class UnicodeService implements IUnicodeService {
   public serviceBrand: any;
 
   private _providers: {[key: string]: IUnicodeVersionProvider} = Object.create(null);
   private _active: string = '';
-  private _activeProvider: IUnicodeVersionProvider;
+  private _activeProvider!: IUnicodeVersionProvider;
 
   private readonly _onChange = new Emitter<string>();
   public readonly onChange = this._onChange.event;
@@ -30,13 +29,6 @@ export class UnicodeService implements IUnicodeService {
     return ((state & 0xffffff) << 3) | ((width & 3) << 1) | (shouldJoin?1:0);
   }
 
-  constructor() {
-    const defaultProvider = new UnicodeV6();
-    this.register(defaultProvider);
-    this._active = defaultProvider.version;
-    this._activeProvider = defaultProvider;
-  }
-
   public dispose(): void {
     this._onChange.dispose();
   }
@@ -60,6 +52,9 @@ export class UnicodeService implements IUnicodeService {
 
   public register(provider: IUnicodeVersionProvider): void {
     this._providers[provider.version] = provider;
+    if (!this._active) {
+      this.activeVersion = provider.version;
+    }
   }
 
   /**