@xterm/xterm 6.1.0-beta.28 → 6.1.0-beta.281

package/src/common/parser/Params.ts

@@ -2,12 +2,18 @@
  * Copyright (c) 2019 The xterm.js authors. All rights reserved.
  * @license MIT
  */
-import { IParams, ParamsArray } from 'common/parser/Types';
+import { IParams, ParamsArray } from './Types';
 
-// max value supported for a single param/subparam (clamped to positive int32 range)
-const MAX_VALUE = 0x7FFFFFFF;
-// max allowed subparams for a single sequence (hardcoded limitation)
-const MAX_SUBPARAMS = 256;
+const enum Constants {
+  /**
+   * Max value supported for a single param/subparam (clamped to positive int32 range)
+   */
+  MAX_VALUE = 0x7FFFFFFF,
+  /**
+   * Max allowed subparams for a single sequence (hardcoded limitation)
+   */
+  MAX_SUBPARAMS = 256
+}
 
 /**
  * Params storage class.
@@ -70,7 +76,7 @@ export class Params implements IParams {
    * @param maxSubParamsLength max length of storable sub parameters
    */
   constructor(public maxLength: number = 32, public maxSubParamsLength: number = 32) {
-    if (maxSubParamsLength > MAX_SUBPARAMS) {
+    if (maxSubParamsLength > Constants.MAX_SUBPARAMS) {
       throw new Error('maxSubParamsLength must not be greater than 256');
     }
     this.params = new Int32Array(maxLength);
@@ -129,6 +135,19 @@ export class Params implements IParams {
     this._digitIsSub = false;
   }
 
+  /**
+   * Reset and add 0 as first param (ZDM).
+   */
+  public resetZdm(): void {
+    this.length = 1;
+    this._subParamsLength = 0;
+    this._rejectDigits = false;
+    this._rejectSubDigits = false;
+    this._digitIsSub = false;
+    this._subParamsIdx[0] = 0;
+    this.params[0] = 0;
+  }
+
   /**
    * Add a parameter value.
    * `Params` only stores up to `maxLength` parameters, any later
@@ -143,17 +162,17 @@ export class Params implements IParams {
       return;
     }
     if (value < -1) {
-      throw new Error('values lesser than -1 are not allowed');
+      throw new Error('values less than -1 are not allowed');
     }
     this._subParamsIdx[this.length] = this._subParamsLength << 8 | this._subParamsLength;
-    this.params[this.length++] = value > MAX_VALUE ? MAX_VALUE : value;
+    this.params[this.length++] = value > Constants.MAX_VALUE ? Constants.MAX_VALUE : value;
   }
 
   /**
    * Add a sub parameter value.
    * The sub parameter is automatically associated with the last parameter value.
    * Thus it is not possible to add a subparameter without any parameter added yet.
-   * `Params` only stores up to `subParamsLength` sub parameters, any later
+   * `Params` only stores up to `maxSubParamsLength` sub parameters, any later
    * sub parameter will be ignored.
    */
   public addSubParam(value: number): void {
@@ -166,9 +185,9 @@ export class Params implements IParams {
       return;
     }
     if (value < -1) {
-      throw new Error('values lesser than -1 are not allowed');
+      throw new Error('values less than -1 are not allowed');
     }
-    this._subParams[this._subParamsLength++] = value > MAX_VALUE ? MAX_VALUE : value;
+    this._subParams[this._subParamsLength++] = value > Constants.MAX_VALUE ? Constants.MAX_VALUE : value;
     this._subParamsIdx[this.length - 1]++;
   }
 
@@ -224,6 +243,6 @@ export class Params implements IParams {
 
     const store = this._digitIsSub ? this._subParams : this.params;
     const cur = store[length - 1];
-    store[length - 1] = ~cur ? Math.min(cur * 10 + value, MAX_VALUE) : value;
+    store[length - 1] = ~cur ? Math.min(cur * 10 + value, Constants.MAX_VALUE) : value;
   }
 }

package/src/common/parser/Types.ts

@@ -3,12 +3,10 @@
  * @license MIT
  */
 
-import { IDisposable } from 'common/Types';
-import { ParserState } from 'common/parser/Constants';
+import { IDisposable, IParams, ParamsArray } from '../Types';
+import { ParserState } from './Constants';
 
-
-/** sequence params serialized to js arrays */
-export type ParamsArray = (number | number[])[];
+export type { IParams, ParamsArray };
 
 /** Params constructor type. */
 export interface IParamsConstructor {
@@ -18,27 +16,6 @@ export interface IParamsConstructor {
   fromArray(values: ParamsArray): IParams;
 }
 
-/** Interface of Params storage class. */
-export interface IParams {
-  /** from ctor */
-  maxLength: number;
-  maxSubParamsLength: number;
-
-  /** param values and its length */
-  params: Int32Array;
-  length: number;
-
-  /** methods */
-  clone(): IParams;
-  toArray(): ParamsArray;
-  reset(): void;
-  addParam(value: number): void;
-  addSubParam(value: number): void;
-  hasSubParams(idx: number): boolean;
-  getSubParams(idx: number): Int32Array | null;
-  getSubParamsAll(): {[idx: number]: Int32Array};
-}
-
 /**
  * Internal state of EscapeSequenceParser.
  * Used as argument of the error handler to allow
@@ -107,7 +84,7 @@ export type EscFallbackHandlerType = (identifier: number) => void;
 /**
  * EXECUTE handler types.
  */
-export type ExecuteHandlerType = () => boolean;
+export type ExecuteHandlerType = (ident?: number) => boolean;
 export type ExecuteFallbackHandlerType = (ident: number) => void;
 
 /**
@@ -134,6 +111,29 @@ export interface IOscHandler {
 }
 export type OscFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
 
+/**
+ * APC handler types.
+ */
+export interface IApcHandler {
+  /**
+   * Announces start of this APC command.
+   * Prepare needed data structures here.
+   */
+  start(): void;
+  /**
+   * Incoming data chunk.
+   */
+  put(data: Uint32Array, start: number, end: number): void;
+  /**
+   * End of APC command. `success` indicates whether the
+   * command finished normally or got aborted, thus final
+   * execution of the command should depend on `success`.
+   * To save memory also cleanup data structures here.
+   */
+  end(success: boolean): boolean | Promise<boolean>;
+}
+export type ApcFallbackHandlerType = (ident: number, action: 'START' | 'PUT' | 'END', payload?: any) => void;
+
 /**
  * PRINT handler types.
  */
@@ -196,6 +196,10 @@ export interface IEscapeSequenceParser extends IDisposable {
   clearOscHandler(ident: number): void;
   setOscHandlerFallback(handler: OscFallbackHandlerType): void;
 
+  registerApcHandler(id: IFunctionIdentifier, handler: IApcHandler): IDisposable;
+  clearApcHandler(id: IFunctionIdentifier): void;
+  setApcHandlerFallback(handler: ApcFallbackHandlerType): void;
+
   setErrorHandler(handler: (state: IParsingState) => IParsingState): void;
   clearErrorHandler(): void;
 }
@@ -223,10 +227,15 @@ export interface IDcsParser extends ISubParser<IDcsHandler, DcsFallbackHandlerTy
   unhook(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
 }
 
+export interface IApcParser extends ISubParser<IApcHandler, ApcFallbackHandlerType> {
+  start(ident: number): void;
+  end(success: boolean, promiseResult?: boolean): void | Promise<boolean>;
+}
+
 /**
  * Interface to denote a specific ESC, CSI or DCS handler slot.
- * The values are used to create an integer respresentation during handler
- * regristation before passed to the subparsers as `ident`.
+ * The values are used to create an integer representation during handler
+ * registration before passed to the subparsers as `ident`.
  * The integer translation is made to allow a faster handler access
  * in `EscapeSequenceParser.parse`.
  */
@@ -252,7 +261,8 @@ export const enum ParserStackType {
   CSI,
   ESC,
   OSC,
-  DCS
+  DCS,
+  APC
 }
 
 // aggregate of resumable handler lists

package/src/common/public/BufferApiView.ts

@@ -4,9 +4,9 @@
  */
 
 import { IBuffer as IBufferApi, IBufferLine as IBufferLineApi, IBufferCell as IBufferCellApi } from '@xterm/xterm';
-import { IBuffer } from 'common/buffer/Types';
-import { BufferLineApiView } from 'common/public/BufferLineApiView';
-import { CellData } from 'common/buffer/CellData';
+import { IBuffer } from '../buffer/Types';
+import { BufferLineApiView } from './BufferLineApiView';
+import { CellData } from '../buffer/CellData';
 
 export class BufferApiView implements IBufferApi {
   constructor(

package/src/common/public/BufferLineApiView.ts

@@ -3,8 +3,8 @@
  * @license MIT
  */
 
-import { CellData } from 'common/buffer/CellData';
-import { IBufferLine, ICellData } from 'common/Types';
+import { CellData } from '../buffer/CellData';
+import { IBufferLine, ICellData } from '../buffer/Types';
 import { IBufferCell as IBufferCellApi, IBufferLine as IBufferLineApi } from '@xterm/xterm';
 
 export class BufferLineApiView implements IBufferLineApi {
@@ -18,10 +18,10 @@ export class BufferLineApiView implements IBufferLineApi {
     }
 
     if (cell) {
-      this._line.loadCell(x, cell as ICellData);
+      this._line.loadCell(x, cell as unknown as ICellData);
       return cell;
     }
-    return this._line.loadCell(x, new CellData());
+    return this._line.loadCell(x, new CellData()) as unknown as IBufferCellApi;
   }
   public translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string {
     return this._line.translateToString(trimRight, startColumn, endColumn);

package/src/common/public/BufferNamespaceApi.ts

@@ -4,10 +4,10 @@
  */
 
 import { IBuffer as IBufferApi, IBufferNamespace as IBufferNamespaceApi } from '@xterm/xterm';
-import { BufferApiView } from 'common/public/BufferApiView';
-import { ICoreTerminal } from 'common/Types';
-import { Disposable } from 'vs/base/common/lifecycle';
-import { Emitter } from 'vs/base/common/event';
+import { BufferApiView } from './BufferApiView';
+import { ICoreTerminal } from '../CoreTerminal';
+import { Disposable } from '../Lifecycle';
+import { Emitter } from '../Event';
 
 export class BufferNamespaceApi extends Disposable implements IBufferNamespaceApi {
   private _normal: BufferApiView;
@@ -20,7 +20,7 @@ export class BufferNamespaceApi extends Disposable implements IBufferNamespaceAp
     super();
     this._normal = new BufferApiView(this._core.buffers.normal, 'normal');
     this._alternate = new BufferApiView(this._core.buffers.alt, 'alternate');
-    this._core.buffers.onBufferActivate(() => this._onBufferChange.fire(this.active));
+    this._register(this._core.buffers.onBufferActivate(() => this._onBufferChange.fire(this.active)));
   }
   public get active(): IBufferApi {
     if (this._core.buffers.active === this._core.buffers.normal) { return this.normal; }

package/src/common/public/ParserApi.ts

@@ -3,9 +3,9 @@
  * @license MIT
  */
 
-import { IParams } from 'common/parser/Types';
+import { IParams } from '../parser/Types';
 import { IDisposable, IFunctionIdentifier, IParser } from '@xterm/xterm';
-import { ICoreTerminal } from 'common/Types';
+import { ICoreTerminal } from '../CoreTerminal';
 
 export class ParserApi implements IParser {
   constructor(private _core: ICoreTerminal) { }
@@ -34,4 +34,7 @@ export class ParserApi implements IParser {
   public addOscHandler(ident: number, callback: (data: string) => boolean | Promise<boolean>): IDisposable {
     return this.registerOscHandler(ident, callback);
   }
+  public registerApcHandler(id: IFunctionIdentifier, callback: (data: string) => boolean | Promise<boolean>): IDisposable {
+    return this._core.registerApcHandler(id, callback);
+  }
 }

package/src/common/public/UnicodeApi.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { ICoreTerminal } from 'common/Types';
+import { ICoreTerminal } from '../CoreTerminal';
 import { IUnicodeHandling, IUnicodeVersionProvider } from '@xterm/xterm';
 
 export class UnicodeApi implements IUnicodeHandling {

package/src/common/services/BufferService.ts

@@ -3,15 +3,16 @@
  * @license MIT
  */
 
-import { Disposable } from 'vs/base/common/lifecycle';
-import { IAttributeData, IBufferLine } from 'common/Types';
-import { BufferSet } from 'common/buffer/BufferSet';
-import { IBuffer, IBufferSet } from 'common/buffer/Types';
-import { IBufferService, IOptionsService, type IBufferResizeEvent } from 'common/services/Services';
-import { Emitter } from 'vs/base/common/event';
-
-export const MINIMUM_COLS = 2; // Less than 2 can mess with wide chars
-export const MINIMUM_ROWS = 1;
+import { Disposable } from '../Lifecycle';
+import { IAttributeData, IBuffer, IBufferLine, IBufferSet } from '../buffer/Types';
+import { BufferSet } from '../buffer/BufferSet';
+import { IBufferService, ILogService, IOptionsService, type IBufferResizeEvent } from './Services';
+import { Emitter } from '../Event';
+
+export const enum BufferServiceConstants {
+  MINIMUM_COLS = 2, // Less than 2 can mess with wide chars
+  MINIMUM_ROWS = 1
+}
 
 export class BufferService extends Disposable implements IBufferService {
   public serviceBrand: any;
@@ -32,11 +33,14 @@ export class BufferService extends Disposable implements IBufferService {
   /** An IBufferline to clone/copy from for new blank lines */
   private _cachedBlankLine: IBufferLine | undefined;
 
-  constructor(@IOptionsService optionsService: IOptionsService) {
+  constructor(
+    @IOptionsService optionsService: IOptionsService,
+    @ILogService logService: ILogService
+  ) {
     super();
-    this.cols = Math.max(optionsService.rawOptions.cols || 0, MINIMUM_COLS);
-    this.rows = Math.max(optionsService.rawOptions.rows || 0, MINIMUM_ROWS);
-    this.buffers = this._register(new BufferSet(optionsService, this));
+    this.cols = Math.max(optionsService.rawOptions.cols || 0, BufferServiceConstants.MINIMUM_COLS);
+    this.rows = Math.max(optionsService.rawOptions.rows || 0, BufferServiceConstants.MINIMUM_ROWS);
+    this.buffers = this._register(new BufferSet(optionsService, this, logService));
     this._register(this.buffers.onBufferActivate(e => {
       this._onScroll.fire(e.activeBuffer.ydisp);
     }));

package/src/common/services/CharsetService.ts

@@ -3,8 +3,8 @@
  * @license MIT
  */
 
-import { ICharsetService } from 'common/services/Services';
-import { ICharset } from 'common/Types';
+import { ICharsetService } from './Services';
+import { ICharset } from '../Types';
 
 export class CharsetService implements ICharsetService {
   public serviceBrand: any;
@@ -14,6 +14,10 @@ export class CharsetService implements ICharsetService {
 
   private _charsets: (ICharset | undefined)[] = [];
 
+  public get charsets(): (ICharset | undefined)[] {
+    return this._charsets;
+  }
+
   public reset(): void {
     this.charset = undefined;
     this._charsets = [];

package/src/common/services/CoreService.ts

@@ -3,11 +3,10 @@
  * @license MIT
  */
 
-import { clone } from 'common/Clone';
-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';
+import { Disposable } from '../Lifecycle';
+import { IDecPrivateModes, IKittyKeyboardState, IModes } from '../Types';
+import { IBufferService, ICoreService, ILogService, IOptionsService } from './Services';
+import { Emitter } from '../Event';
 
 const DEFAULT_MODES: IModes = Object.freeze({
   insertMode: false
@@ -17,22 +16,33 @@ const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   applicationCursorKeys: false,
   applicationKeypad: false,
   bracketedPasteMode: false,
+  colorSchemeUpdates: false,
   cursorBlink: undefined,
   cursorStyle: undefined,
   origin: false,
   reverseWraparound: false,
   sendFocus: false,
   synchronizedOutput: false,
+  win32InputMode: false,
   wraparound: true // defaults: xterm - true, vt100 - false
 });
 
+const DEFAULT_KITTY_KEYBOARD_STATE = (): IKittyKeyboardState => ({
+  flags: 0,
+  mainFlags: 0,
+  altFlags: 0,
+  mainStack: [],
+  altStack: []
+});
+
 export class CoreService extends Disposable implements ICoreService {
   public serviceBrand: any;
 
-  public isCursorInitialized: boolean = false;
+  public isCursorInitialized: boolean;
   public isCursorHidden: boolean = false;
   public modes: IModes;
   public decPrivateModes: IDecPrivateModes;
+  public kittyKeyboard: IKittyKeyboardState;
 
   private readonly _onData = this._register(new Emitter<string>());
   public readonly onData = this._onData.event;
@@ -49,13 +59,16 @@ export class CoreService extends Disposable implements ICoreService {
     @IOptionsService private readonly _optionsService: IOptionsService
   ) {
     super();
-    this.modes = clone(DEFAULT_MODES);
-    this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
+    this.isCursorInitialized = _optionsService.rawOptions.showCursorImmediately ?? false;
+    this.modes = structuredClone(DEFAULT_MODES);
+    this.decPrivateModes = structuredClone(DEFAULT_DEC_PRIVATE_MODES);
+    this.kittyKeyboard = DEFAULT_KITTY_KEYBOARD_STATE();
   }
 
   public reset(): void {
-    this.modes = clone(DEFAULT_MODES);
-    this.decPrivateModes = clone(DEFAULT_DEC_PRIVATE_MODES);
+    this.modes = structuredClone(DEFAULT_MODES);
+    this.decPrivateModes = structuredClone(DEFAULT_DEC_PRIVATE_MODES);
+    this.kittyKeyboard = DEFAULT_KITTY_KEYBOARD_STATE();
   }
 
   public triggerDataEvent(data: string, wasUserInput: boolean = false): void {