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

package/src/browser/services/CharacterJoinerService.ts

@@ -3,13 +3,13 @@
  * @license MIT
  */
 
-import { IBufferLine, ICellData, CharData } from 'common/Types';
-import { ICharacterJoiner } from 'browser/Types';
-import { AttributeData } from 'common/buffer/AttributeData';
-import { WHITESPACE_CELL_CHAR, Content } from 'common/buffer/Constants';
-import { CellData } from 'common/buffer/CellData';
-import { IBufferService } from 'common/services/Services';
-import { ICharacterJoinerService } from 'browser/services/Services';
+import { CharData, IBufferLine, ICellData } from '../../common/buffer/Types';
+import { ICharacterJoiner } from '../Types';
+import { AttributeData } from '../../common/buffer/AttributeData';
+import { WHITESPACE_CELL_CHAR, Content } from '../../common/buffer/Constants';
+import { CellData } from '../../common/buffer/CellData';
+import { IBufferService } from '../../common/services/Services';
+import { ICharacterJoinerService } from './Services';
 
 export class JoinedCellData extends AttributeData implements ICellData {
   private _width: number;
@@ -100,6 +100,7 @@ export class CharacterJoinerService implements ICharacterJoinerService {
 
     const ranges: [number, number][] = [];
     const lineStr = line.translateToString(true);
+    const trimmedLength = line.getTrimmedLength();
 
     // Because some cells can be represented by multiple javascript characters,
     // we track the cell and the string indexes separately. This allows us to
@@ -111,7 +112,7 @@ export class CharacterJoinerService implements ICharacterJoinerService {
     let rangeAttrFG = line.getFg(0);
     let rangeAttrBG = line.getBg(0);
 
-    for (let x = 0; x < line.getTrimmedLength(); x++) {
+    for (let x = 0; x < trimmedLength; x++) {
       line.loadCell(x, this._workCell);
 
       if (this._workCell.getWidth() === 0) {
@@ -147,7 +148,7 @@ export class CharacterJoinerService implements ICharacterJoinerService {
     }
 
     // Process any trailing ranges.
-    if (this._bufferService.cols - rangeStartColumn > 1) {
+    if (trimmedLength - rangeStartColumn > 1) {
       const joinedRanges = this._getJoinedRanges(
         lineStr,
         rangeStartStringIndex,
@@ -216,7 +217,8 @@ export class CharacterJoinerService implements ICharacterJoinerService {
       return;
     }
 
-    for (let x = startCol; x < this._bufferService.cols; x++) {
+    const trimmedLength = line.getTrimmedLength();
+    for (let x = startCol; x < trimmedLength; x++) {
       const width = line.getWidth(x);
       const length = line.getString(x).length || WHITESPACE_CELL_CHAR.length;
 
@@ -264,7 +266,7 @@ export class CharacterJoinerService implements ICharacterJoinerService {
     // If there is still a range left at the end, it must extend all the way to
     // the end of the line.
     if (currentRange) {
-      currentRange[1] = this._bufferService.cols;
+      currentRange[1] = trimmedLength;
     }
   }
 

package/src/browser/services/CoreBrowserService.ts

@@ -4,16 +4,16 @@
  */
 
 import { ICoreBrowserService } from './Services';
-import { Emitter, Event } from 'vs/base/common/event';
-import { addDisposableListener } from 'vs/base/browser/dom';
-import { Disposable, MutableDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { Emitter, EventUtils } from '../../common/Event';
+import { addDisposableListener } from '../Dom';
+import { Disposable, MutableDisposable, toDisposable } from '../../common/Lifecycle';
 
 export class CoreBrowserService extends Disposable implements ICoreBrowserService {
   public serviceBrand: undefined;
 
   private _isFocused = false;
   private _cachedIsFocused: boolean | undefined = undefined;
-  private _screenDprMonitor = this._register(new ScreenDprMonitor(this._window));
+  private _screenDprMonitor: ScreenDprMonitor;
 
   private readonly _onDprChange = this._register(new Emitter<number>());
   public readonly onDprChange = this._onDprChange.event;
@@ -27,9 +27,11 @@ export class CoreBrowserService extends Disposable implements ICoreBrowserServic
   ) {
     super();
 
+    this._screenDprMonitor = this._register(new ScreenDprMonitor(this._window));
+
     // Monitor device pixel ratio
     this._register(this.onWindowChange(w => this._screenDprMonitor.setWindow(w)));
-    this._register(Event.forward(this._screenDprMonitor.onDprChange, this._onDprChange));
+    this._register(EventUtils.forward(this._screenDprMonitor.onDprChange, this._onDprChange));
 
     this._register(addDisposableListener(this._textarea, 'focus', () => this._isFocused = true));
     this._register(addDisposableListener(this._textarea, 'blur', () => this._isFocused = false));

package/src/browser/services/KeyboardService.ts

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2025 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { IKeyboardService } from './Services';
+import { evaluateKeyboardEvent } from '../../common/input/Keyboard';
+import { KittyKeyboard, KittyKeyboardEventType, KittyKeyboardFlags } from '../../common/input/KittyKeyboard';
+import { Win32InputMode } from '../../common/input/Win32InputMode';
+import { isMac } from '../../common/Platform';
+import { ICoreService, IOptionsService } from '../../common/services/Services';
+import { IKeyboardResult } from '../../common/Types';
+
+export class KeyboardService implements IKeyboardService {
+  public serviceBrand: undefined;
+
+  private _win32InputMode: Win32InputMode | undefined;
+  private _kittyKeyboard: KittyKeyboard | undefined;
+
+  constructor(
+    @ICoreService private readonly _coreService: ICoreService,
+    @IOptionsService private readonly _optionsService: IOptionsService
+  ) {
+  }
+
+  private _getWin32InputMode(): Win32InputMode {
+    this._win32InputMode ??= new Win32InputMode();
+    return this._win32InputMode;
+  }
+
+  private _getKittyKeyboard(): KittyKeyboard {
+    this._kittyKeyboard ??= new KittyKeyboard();
+    return this._kittyKeyboard;
+  }
+
+  public evaluateKeyDown(event: KeyboardEvent): IKeyboardResult {
+    // Win32 input mode takes priority (most raw)
+    if (this.useWin32InputMode) {
+      return this._getWin32InputMode().evaluateKeyboardEvent(event, true);
+    }
+    const kittyFlags = this._coreService.kittyKeyboard.flags;
+    return this.useKitty
+      ? this._getKittyKeyboard().evaluate(event, kittyFlags, event.repeat ? KittyKeyboardEventType.REPEAT : KittyKeyboardEventType.PRESS, isMac && this._optionsService.rawOptions.macOptionIsMeta)
+      : evaluateKeyboardEvent(event, this._coreService.decPrivateModes.applicationCursorKeys, isMac, this._optionsService.rawOptions.macOptionIsMeta);
+  }
+
+  public evaluateKeyUp(event: KeyboardEvent): IKeyboardResult | undefined {
+    // Win32 input mode sends key up events
+    if (this.useWin32InputMode) {
+      return this._getWin32InputMode().evaluateKeyboardEvent(event, false);
+    }
+    const kittyFlags = this._coreService.kittyKeyboard.flags;
+    if (this.useKitty && (kittyFlags & KittyKeyboardFlags.REPORT_EVENT_TYPES)) {
+      return this._getKittyKeyboard().evaluate(event, kittyFlags, KittyKeyboardEventType.RELEASE, isMac && this._optionsService.rawOptions.macOptionIsMeta);
+    }
+    return undefined;
+  }
+
+  public get useKitty(): boolean {
+    const kittyFlags = this._coreService.kittyKeyboard.flags;
+    return !!(this._optionsService.rawOptions.vtExtensions?.kittyKeyboard && KittyKeyboard.shouldUseProtocol(kittyFlags));
+  }
+
+  public get useWin32InputMode(): boolean {
+    return !!(this._optionsService.rawOptions.vtExtensions?.win32InputMode && this._coreService.decPrivateModes.win32InputMode);
+  }
+}

package/src/browser/services/LinkProviderService.ts

@@ -1,6 +1,6 @@
-import { ILinkProvider, ILinkProviderService } from 'browser/services/Services';
-import { Disposable, toDisposable } from 'vs/base/common/lifecycle';
-import { IDisposable } from 'common/Types';
+import { ILinkProvider, ILinkProviderService } from './Services';
+import { Disposable, toDisposable } from '../../common/Lifecycle';
+import { IDisposable } from '../../common/Types';
 
 export class LinkProviderService extends Disposable implements ILinkProviderService {
   declare public serviceBrand: undefined;

package/src/browser/services/MouseCoordsService.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+import { getWindow } from '../Dom';
+import { getCoords, getCoordsRelativeToElement } from '../input/Mouse';
+import { ICharSizeService, IMouseCoordsService, IRenderService } from './Services';
+
+export class MouseCoordsService implements IMouseCoordsService {
+  public serviceBrand: undefined;
+
+  constructor(
+    @ICharSizeService private readonly _charSizeService: ICharSizeService,
+    @IRenderService private readonly _renderService: IRenderService
+  ) {
+  }
+
+  public getCoords(event: {clientX: number, clientY: number}, element: HTMLElement, colCount: number, rowCount: number, isSelection?: boolean): [number, number] | undefined {
+    return getCoords(
+      getWindow(element),
+      event,
+      element,
+      colCount,
+      rowCount,
+      this._charSizeService.hasValidSize,
+      this._renderService.dimensions.css.cell.width,
+      this._renderService.dimensions.css.cell.height,
+      isSelection
+    );
+  }
+
+  public getMouseReportCoords(event: MouseEvent, element: HTMLElement): { col: number, row: number, x: number, y: number } | undefined {
+    const coords = getCoordsRelativeToElement(getWindow(element), event, element);
+    if (!this._charSizeService.hasValidSize) {
+      return undefined;
+    }
+    coords[0] = Math.min(Math.max(coords[0], 0), this._renderService.dimensions.css.canvas.width - 1);
+    coords[1] = Math.min(Math.max(coords[1], 0), this._renderService.dimensions.css.canvas.height - 1);
+    return {
+      col: Math.floor(coords[0] / this._renderService.dimensions.css.cell.width),
+      row: Math.floor(coords[1] / this._renderService.dimensions.css.cell.height),
+      x: Math.floor(coords[0]),
+      y: Math.floor(coords[1])
+    };
+  }
+}