@theia/core 1.71.0-next.6 → 1.71.0-next.72

package/src/browser/saveable-service.ts

@@ -22,6 +22,7 @@ import { AutoSaveMode, Saveable, SaveableSource, SaveableWidget, SaveOptions, Sa
 import { waitForClosed, Widget } from './widgets';
 import { FrontendApplicationContribution } from './frontend-application-contribution';
 import { FrontendApplication } from './frontend-application';
+import { WindowFocusService } from './window/window-focus-service';
 import throttle = require('lodash.throttle');
 
 export const SaveErrorChecker = Symbol('SaveErrorChecker');
@@ -49,6 +50,9 @@ export class SaveableService implements FrontendApplicationContribution {
     @inject(ContributionProvider) @named(SaveErrorChecker)
     protected readonly errorCheckers: ContributionProvider<SaveErrorChecker>;
 
+    @inject(WindowFocusService)
+    protected readonly windowFocusService: WindowFocusService;
+
     protected saveThrottles = new Map<Widget, AutoSaveThrottle>();
     protected saveMode: AutoSaveMode = 'off';
     protected saveDelay = 1000;
@@ -131,6 +135,35 @@ export class SaveableService implements FrontendApplicationContribution {
             this.saveThrottles.get(e)?.dispose();
             this.saveThrottles.delete(e);
         });
+        // Save all dirty editors when any application window loses focus
+        this.windowFocusService.onDidWindowChangeFocus(({ hasFocus }) => {
+            if (!hasFocus) {
+                this.saveOnWindowBlur();
+            }
+        });
+    }
+
+    /**
+     * Save all dirty saveables when the application window loses focus.
+     * Triggered for both `onFocusChange` and `onWindowChange` auto-save modes,
+     * matching VSCode's behavior where a window focus loss is a superset of
+     * editor focus loss.
+     */
+    protected saveOnWindowBlur(): void {
+        if (this.saveMode !== 'onWindowChange' && this.saveMode !== 'onFocusChange') {
+            return;
+        }
+        if (!this.shell) {
+            return;
+        }
+        for (const widget of this.shell.widgets) {
+            const saveable = Saveable.get(widget);
+            if (saveable && this.shouldAutoSave(widget, saveable)) {
+                saveable.save({
+                    saveReason: SaveReason.FocusChange
+                });
+            }
+        }
     }
 
     protected updateAutoSaveMode(mode: AutoSaveMode): void {
@@ -169,39 +202,13 @@ export class SaveableService implements FrontendApplicationContribution {
                         saveReason: SaveReason.AfterDelay
                     });
                 }
-            },
-            this.addBlurListener(widget, saveable)
+            }
         );
         this.saveThrottles.set(widget, saveThrottle);
         this.applySaveableWidget(widget, saveable);
         return saveThrottle;
     }
 
-    protected addBlurListener(widget: Widget, saveable: Saveable): Disposable {
-        const document = widget.node.ownerDocument;
-        const listener = (() => {
-            if (this.saveMode === 'onWindowChange' && !this.windowHasFocus(document) && this.shouldAutoSave(widget, saveable)) {
-                saveable.save({
-                    saveReason: SaveReason.FocusChange
-                });
-            }
-        }).bind(this);
-        document.addEventListener('blur', listener);
-        return Disposable.create(() => {
-            document.removeEventListener('blur', listener);
-        });
-    }
-
-    protected windowHasFocus(document: Document): boolean {
-        if (document.visibilityState === 'hidden') {
-            return false;
-        } else if (document.hasFocus()) {
-            return true;
-        }
-        // TODO: Add support for iframes
-        return false;
-    }
-
     protected shouldAutoSave(widget: Widget, saveable: Saveable): boolean {
         const uri = NavigatableWidget.getUri(widget);
         if (uri?.scheme === UNTITLED_SCHEME) {

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -16,6 +16,7 @@
 
 import { inject, injectable, postConstruct } from 'inversify';
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
 import { ContextKeyService } from '../../context-key-service';
 import { CommandRegistry, Disposable, DisposableCollection, nls } from '../../../common';
 import { Anchor, ContextMenuAccess, ContextMenuRenderer } from '../../context-menu-renderer';
@@ -150,7 +151,10 @@ export class TabBarToolbar extends ReactWidget {
 
     protected renderMore(): React.ReactNode {
         return !!this.more.size && <div key='__more__' className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled'}>
-            <div id='__more__' className={codicon('ellipsis', true)} onClick={this.showMoreContextMenu}
+            <div id='__more__' className={codicon('ellipsis', true)}
+                {...buttonKeyboardProps(nls.localizeByDefault('More Actions...'))}
+                onClick={this.showMoreContextMenu}
+                onKeyDown={this.handleMoreKeyDown}
                 title={nls.localizeByDefault('More Actions...')} />
         </div>;
     }
@@ -162,6 +166,15 @@ export class TabBarToolbar extends ReactWidget {
         this.renderMoreContextMenu(anchor);
     };
 
+    protected handleMoreKeyDown = (event: React.KeyboardEvent) => {
+        if (isActivationKey(event)) {
+            event.preventDefault();
+            event.stopPropagation();
+            const { left, bottom } = (event.currentTarget as HTMLElement).getBoundingClientRect();
+            this.renderMoreContextMenu({ x: left, y: bottom });
+        }
+    };
+
     renderMoreContextMenu(anchor: Anchor): ContextMenuAccess {
         const toDisposeOnHide = new DisposableCollection();
         this.addClass('menu-open');

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -23,6 +23,7 @@ import { KeybindingRegistry } from '../../keybinding';
 import { ACTION_ITEM } from '../../widgets';
 import { TabBarToolbar } from './tab-bar-toolbar';
 import * as React from 'react';
+import { buttonKeyboardProps, isActivationKey } from '../../keyboard/keyboard-utils';
 import { ActionMenuNode, GroupImpl, MenuNode } from '../../../common/menu';
 
 export interface TabBarToolbarItem {
@@ -195,16 +196,24 @@ export class RenderedToolbarItemImpl extends AbstractToolbarItemImpl<RenderedToo
     };
 
     protected executeCommand(e: React.MouseEvent<HTMLElement>, widget: Widget): void {
+        this.doExecuteCommand(e, widget);
+    };
+
+    protected doExecuteCommand(e: React.SyntheticEvent<HTMLElement>, widget: Widget): void {
         e.preventDefault();
         e.stopPropagation();
-
         if (!this.isEnabled(widget)) {
             return;
         }
-
         if (this.action.command) {
             this.commandRegistry.executeCommand(this.action.command, widget);
         }
+    }
+
+    protected onKeyDownEvent = (e: React.KeyboardEvent<HTMLElement>, widget: Widget) => {
+        if (isActivationKey(e)) {
+            this.doExecuteCommand(e, widget);
+        }
     };
 
     protected renderItem(widget: Widget): React.ReactNode {
@@ -249,7 +258,9 @@ export class RenderedToolbarItemImpl extends AbstractToolbarItemImpl<RenderedToo
             onMouseUp={this.onMouseUpEvent}
             onMouseOut={this.onMouseUpEvent} >
             <div id={this.action.id} className={classNames.join(' ')}
+                {...buttonKeyboardProps(tooltip)}
                 onClick={e => this.executeCommand(e, widget)}
+                onKeyDown={e => this.onKeyDownEvent(e, widget)}
                 title={tooltip} > {innerText}
             </div>
         </div>;

package/src/browser/style/card.css

@@ -101,11 +101,13 @@
     transition: opacity 0.15s;
 }
 
-.theia-Card:hover .theia-Card-footer-time {
+.theia-Card:hover .theia-Card-footer-time,
+.theia-Card:focus-within .theia-Card-footer-time {
     opacity: 0;
 }
 
-.theia-Card:hover .theia-Card-footer-actions {
+.theia-Card:hover .theia-Card-footer-actions,
+.theia-Card:focus-within .theia-Card-footer-actions {
     opacity: 1;
     pointer-events: auto;
 }

package/src/browser/style/hover-service.css

@@ -30,6 +30,8 @@
   padding: var(--theia-ui-padding);
   max-width: var(--theia-hover-max-width);
   user-select: text;
+  --vscode-scmGraph-historyItemHoverAdditionsForeground: var(--theia-scmGraph-historyItemHoverAdditionsForeground);
+  --vscode-scmGraph-historyItemHoverDeletionsForeground: var(--theia-scmGraph-historyItemHoverDeletionsForeground);
 }
 
 /* overwrite potentially different default user agent styles */
@@ -60,6 +62,11 @@
   background-color: var(--theia-editorHoverWidget-statusBarBackground);
 }
 
+.theia-hover .codicon {
+  vertical-align: middle;
+  margin-bottom: 2px;
+}
+
 .theia-hover code {
   background-color: var(--theia-textCodeBlock-background);
   font-family: var(--theia-code-font-family);

package/src/browser/window/browser-window-module.ts

@@ -24,6 +24,7 @@ import { SecondaryWindowService } from './secondary-window-service';
 import { DefaultSecondaryWindowService } from './default-secondary-window-service';
 import { bindRootContributionProvider } from '../../common';
 import { WindowTitleContribution } from './window-title-service';
+import { WindowFocusService } from './window-focus-service';
 
 export default new ContainerModule(bind => {
     bind(DefaultWindowService).toSelf().inSingletonScope();
@@ -31,5 +32,6 @@ export default new ContainerModule(bind => {
     bind(FrontendApplicationContribution).toService(DefaultWindowService);
     bind(ClipboardService).to(BrowserClipboardService).inSingletonScope();
     bind(SecondaryWindowService).to(DefaultSecondaryWindowService).inSingletonScope();
+    bind(WindowFocusService).toSelf().inSingletonScope();
     bindRootContributionProvider(bind, WindowTitleContribution);
 });

package/src/browser/window/default-secondary-window-service.ts

@@ -22,6 +22,7 @@ import { Saveable } from '../saveable';
 import { Emitter, environment, Event, PreferenceService } from '../../common';
 import { SaveableService } from '../saveable-service';
 import { getAllWidgetsFromSecondaryWindow, getDefaultRestoreArea } from '../secondary-window-handler';
+import { WindowFocusService } from './window-focus-service';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
@@ -53,6 +54,9 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     @inject(SaveableService)
     protected readonly saveResourceService: SaveableService;
 
+    @inject(WindowFocusService)
+    protected readonly windowFocusService: WindowFocusService;
+
     @postConstruct()
     init(): void {
         // Set up messaging with secondary windows
@@ -106,6 +110,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
             this.secondaryWindows.push(newWindow);
             this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
+                const focusRegistration = this.windowFocusService.registerWindow(newWindow);
                 newWindow.addEventListener('beforeunload', evt => {
                     const widgets = getAllWidgetsFromSecondaryWindow(newWindow) ?? [widget];
                     for (const w of widgets) {
@@ -120,6 +125,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                 }, { capture: true });
 
                 newWindow.addEventListener('unload', () => {
+                    focusRegistration.dispose();
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
                         this.onWindowClosedEmitter.fire(newWindow);

package/src/browser/window/window-focus-service.ts

@@ -0,0 +1,187 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+// based on https://github.com/microsoft/vscode/blob/ea6aac971b851ff8675f9ea04f8c0dfc36034a89/src/vs/workbench/services/host/browser/browserHostService.ts
+// and https://github.com/microsoft/vscode/blob/ea6aac971b851ff8675f9ea04f8c0dfc36034a89/src/vs/base/browser/dom.ts#L1319 (FocusTracker)
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { injectable, postConstruct } from 'inversify';
+import { Disposable, DisposableCollection, Emitter, Event } from '../../common';
+
+export interface WindowFocusEvent {
+    win: Window;
+    hasFocus: boolean;
+}
+
+/**
+ * Tracks focus state for each registered application window independently.
+ *
+ * The main window is registered automatically. Secondary windows should be
+ * registered via {@link registerWindow} — typically by the service responsible
+ * for creating them.
+ *
+ * Uses two complementary signals per window for robust detection:
+ * - `window` `focus`/`blur` events (OS-level window focus changes)
+ * - `document` `visibilitychange` events (browser tab switches)
+ *
+ * Blur events are debounced per window with `setTimeout(0)` so that focus
+ * moving between elements within the same window does not produce a false
+ * blur: the subsequent `focus` event cancels the pending blur before it fires.
+ *
+ * Each per-window event is latched — it only fires when that window's focus
+ * state actually changes.
+ */
+@injectable()
+export class WindowFocusService implements Disposable {
+
+    protected readonly onDidWindowChangeFocusEmitter = new Emitter<WindowFocusEvent>();
+
+    /**
+     * Fires when an individual window's focus state changes.
+     * The event payload identifies which window changed and whether it gained or lost focus.
+     *
+     * A window losing focus to another application window will fire separately
+     * for each window involved: one event with `hasFocus: false` for the window
+     * that lost focus, and one with `hasFocus: true` for the window that gained it.
+     */
+    readonly onDidWindowChangeFocus: Event<WindowFocusEvent> = this.onDidWindowChangeFocusEmitter.event;
+
+    protected readonly toDispose = new DisposableCollection(this.onDidWindowChangeFocusEmitter);
+
+    /** Per-window tracking state. */
+    protected readonly windowStates = new Map<Window, WindowTrackingState>();
+
+    @postConstruct()
+    protected init(): void {
+        this.registerWindow(window);
+    }
+
+    /**
+     * Register a window for focus tracking. The returned {@link Disposable}
+     * removes the window from tracking when disposed.
+     *
+     * The main window is registered automatically. Call this for secondary
+     * windows when they are created.
+     */
+    registerWindow(win: Window): Disposable {
+        if (this.windowStates.has(win)) {
+            return Disposable.NULL;
+        }
+
+        const state: WindowTrackingState = {
+            lastFocusState: this.windowHasFocus(win),
+            pendingBlurTimeout: undefined,
+        };
+        this.windowStates.set(win, state);
+
+        const onFocus = () => this.handleFocus(win, state);
+        const onBlur = () => this.scheduleBlur(win, state);
+        const onVisibilityChange = () => this.updateWindowFocusState(win, state);
+
+        win.addEventListener('focus', onFocus);
+        win.addEventListener('blur', onBlur);
+        win.document.addEventListener('visibilitychange', onVisibilityChange);
+
+        const cleanup = Disposable.create(() => {
+            this.cancelPendingBlur(state);
+            this.windowStates.delete(win);
+            win.removeEventListener('focus', onFocus);
+            win.removeEventListener('blur', onBlur);
+            try {
+                win.document.removeEventListener('visibilitychange', onVisibilityChange);
+            } catch {
+                // The window may already be closed
+            }
+        });
+
+        this.toDispose.push(cleanup);
+        return cleanup;
+    }
+
+    /**
+     * Whether any registered window currently has focus.
+     */
+    get hasFocus(): boolean {
+        for (const win of this.windowStates.keys()) {
+            if (this.windowHasFocus(win)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected windowHasFocus(win: Window): boolean {
+        try {
+            return win.document.hasFocus();
+        } catch {
+            // The window may have been closed
+            return false;
+        }
+    }
+
+    protected handleFocus(win: Window, state: WindowTrackingState): void {
+        // Cancel this window's pending blur — focus arrived before the timeout,
+        // meaning focus just moved between elements within this window.
+        this.cancelPendingBlur(state);
+        this.updateWindowFocusState(win, state);
+    }
+
+    /**
+     * Schedule a deferred blur check for this specific window.
+     * If no `focus` event arrives on this same window before the timeout fires,
+     * we treat it as a real focus loss for that window.
+     */
+    protected scheduleBlur(win: Window, state: WindowTrackingState): void {
+        this.cancelPendingBlur(state);
+        state.pendingBlurTimeout = setTimeout(() => {
+            state.pendingBlurTimeout = undefined;
+            this.updateWindowFocusState(win, state);
+        }, 0);
+    }
+
+    protected cancelPendingBlur(state: WindowTrackingState): void {
+        if (state.pendingBlurTimeout !== undefined) {
+            clearTimeout(state.pendingBlurTimeout);
+            state.pendingBlurTimeout = undefined;
+        }
+    }
+
+    /**
+     * Re-evaluate a single window's focus and fire if it changed (latching).
+     */
+    protected updateWindowFocusState(win: Window, state: WindowTrackingState): void {
+        const focused = this.windowHasFocus(win);
+        if (focused !== state.lastFocusState) {
+            state.lastFocusState = focused;
+            this.onDidWindowChangeFocusEmitter.fire({ win, hasFocus: focused });
+        }
+    }
+
+    dispose(): void {
+        for (const state of this.windowStates.values()) {
+            this.cancelPendingBlur(state);
+        }
+        this.toDispose.dispose();
+    }
+}
+
+interface WindowTrackingState {
+    lastFocusState: boolean;
+    pendingBlurTimeout: ReturnType<typeof setTimeout> | undefined;
+}

package/src/common/event.spec.ts

@@ -29,4 +29,84 @@ describe('Event Objects', () => {
         expect(counter).eq(1);
     });
 
+    describe('Emitter errorHandling option', () => {
+
+        it('should log errors by default', () => {
+            const emitter = new Emitter<void>();
+            const errors: unknown[] = [];
+            const originalError = console.error;
+            console.error = (e: unknown) => errors.push(e);
+
+            try {
+                emitter.event(() => { throw new Error('test error'); });
+                emitter.fire(undefined);
+
+                expect(errors).to.have.lengthOf(1);
+                expect((errors[0] as Error).message).to.equal('test error');
+            } finally {
+                console.error = originalError;
+            }
+        });
+
+        it('should propagate a single error when errorHandling is propagate', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+
+            emitter.event(() => { throw new Error('boom'); });
+
+            expect(() => emitter.fire(undefined)).to.throw('boom');
+        });
+
+        it('should call all listeners before propagating the error', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+            let secondCalled = false;
+
+            emitter.event(() => { throw new Error('first fails'); });
+            emitter.event(() => { secondCalled = true; });
+
+            expect(() => emitter.fire(undefined)).to.throw('first fails');
+            expect(secondCalled).to.be.true;
+        });
+
+        it('should throw AggregateError when multiple listeners fail with propagate', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+
+            emitter.event(() => { throw new Error('error 1'); });
+            emitter.event(() => { throw new Error('error 2'); });
+
+            try {
+                emitter.fire(undefined);
+                expect.fail('Expected an error to be thrown');
+            } catch (err) {
+                expect(err).to.be.instanceOf(AggregateError);
+                const aggregate = err as AggregateError;
+                expect(aggregate.errors).to.have.lengthOf(2);
+                expect(aggregate.errors[0].message).to.equal('error 1');
+                expect(aggregate.errors[1].message).to.equal('error 2');
+            }
+        });
+
+        it('should invoke custom error handler for each error', () => {
+            const errors: unknown[] = [];
+            const emitter = new Emitter<void>({ errorHandling: e => errors.push(e) });
+
+            emitter.event(() => { throw new Error('handled 1'); });
+            emitter.event(() => { throw new Error('handled 2'); });
+            emitter.fire(undefined);
+
+            expect(errors).to.have.lengthOf(2);
+            expect((errors[0] as Error).message).to.equal('handled 1');
+            expect((errors[1] as Error).message).to.equal('handled 2');
+        });
+
+        it('should not throw when no listeners fail with propagate', () => {
+            const emitter = new Emitter<void>({ errorHandling: 'propagate' });
+            let called = false;
+
+            emitter.event(() => { called = true; });
+            emitter.fire(undefined);
+
+            expect(called).to.be.true;
+        });
+    });
+
 });

package/src/common/event.ts

@@ -123,6 +123,8 @@ class CallbackList implements Iterable<Callback> {
     private _callbacks: Function[] | undefined;
     private _contexts: any[] | undefined;
 
+    constructor(private readonly errorHandling: ErrorHandlingStrategy = 'log') {}
+
     get length(): number {
         return this._callbacks && this._callbacks.length || 0;
     }
@@ -179,13 +181,25 @@ class CallbackList implements Iterable<Callback> {
 
     public invoke(...args: any[]): any[] {
         const ret: any[] = [];
+        const errors: unknown[] = [];
         for (const callback of this) {
             try {
                 ret.push(callback(...args));
             } catch (e) {
-                console.error(e);
+                if (this.errorHandling === 'propagate') {
+                    errors.push(e);
+                } else if (typeof this.errorHandling === 'function') {
+                    this.errorHandling(e);
+                } else {
+                    console.error(e);
+                }
             }
         }
+        if (errors.length === 1) {
+            throw errors[0];
+        } else if (errors.length > 1) {
+            throw new AggregateError(errors, 'Multiple event listeners failed');
+        }
         return ret;
     }
 
@@ -199,9 +213,24 @@ class CallbackList implements Iterable<Callback> {
     }
 }
 
+/**
+ * A strategy for handling errors in firing an emitter's event, one of
+ *
+ * - `'log'` (default): errors are caught and logged via `console.error`
+ * - `'propagate'`: all listeners are called; if any throw, the errors are collected
+ *   and re-thrown after all listeners complete (single error re-thrown directly,
+ *   multiple errors wrapped in an `AggregateError`)
+ * - `(error: unknown) => void`: a custom callback invoked for each error
+ */
+export type ErrorHandlingStrategy = 'log' | 'propagate' | ((error: unknown) => void);
+
 export interface EmitterOptions {
     onFirstListenerAdd?: Function;
     onLastListenerRemove?: Function;
+    /**
+     * How errors thrown by event listeners are handled during {@link Emitter.fire}.
+     */
+    errorHandling?: ErrorHandlingStrategy;
 }
 
 export class Emitter<T = any> {
@@ -229,7 +258,7 @@ export class Emitter<T = any> {
         if (!this._event) {
             this._event = Object.assign((listener: (e: T) => any, thisArgs?: any, disposables?: DisposableGroup) => {
                 if (!this._callbacks) {
-                    this._callbacks = new CallbackList();
+                    this._callbacks = new CallbackList(this._options?.errorHandling);
                 }
                 if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
                     this._options.onFirstListenerAdd(this);

package/src/common/glob.ts

@@ -44,8 +44,8 @@ export interface SiblingClause {
     when: string;
 }
 
-const GLOBSTAR = '**';
-const GLOB_SPLIT = '/';
+export const GLOBSTAR = '**';
+export const GLOB_SPLIT = '/';
 const PATH_REGEX = '[/\\\\]';        // any slash or backslash
 const NO_PATH_REGEX = '[^/\\\\]';    // any non-slash and non-backslash
 const ALL_FORWARD_SLASHES = /\//g;