@xterm/xterm 6.1.0-beta.26 → 6.1.0-beta.260

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])
+    };
+  }
+}