@theia/core 1.71.0-next.49 → 1.71.0-next.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/core",
-  "version": "1.71.0-next.49+ff8893f59",
+  "version": "1.71.0-next.57+1fc9a8239",
   "description": "Theia is a cloud & desktop IDE framework implemented in TypeScript.",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
@@ -17,8 +17,8 @@
     "@lumino/virtualdom": "^2.0.4",
     "@lumino/widgets": "2.7.5",
     "@parcel/watcher": "^2.5.6",
-    "@theia/application-package": "1.71.0-next.49+ff8893f59",
-    "@theia/request": "1.71.0-next.49+ff8893f59",
+    "@theia/application-package": "1.71.0-next.57+1fc9a8239",
+    "@theia/request": "1.71.0-next.57+1fc9a8239",
     "@types/body-parser": "^1.19.6",
     "@types/express": "^4.17.21",
     "@types/fs-extra": "^4.0.2",
@@ -221,5 +221,5 @@
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "ff8893f5957f8e505176ecd8c3ef10d722d47172"
+  "gitHead": "1fc9a8239357c913ab79f1922b6e87aecd79cfdb"
 }

package/src/browser/common-frontend-contribution.ts

@@ -718,8 +718,8 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             execute: title => title?.owner && this.shell.toggleMaximized(title?.owner),
         }));
         commandRegistry.registerCommand(CommonCommands.SHOW_MENU_BAR, {
-            isEnabled: () => !isOSX,
-            isVisible: () => !isOSX,
+            isEnabled: () => !this.isElectron() || !isOSX,
+            isVisible: () => !this.isElectron() || !isOSX,
             execute: () => {
                 const menuBarVisibility = 'window.menuBarVisibility';
                 const visibility = this.preferences[menuBarVisibility];

package/src/browser/connection-status-service.ts

@@ -205,7 +205,7 @@ export class ApplicationConnectionStatusContribution extends DefaultFrontendAppl
     protected handleOffline(): void {
         this.statusBar.setElement(this.statusbarId, {
             alignment: StatusBarAlignment.LEFT,
-            text: nls.localize('theia/core/offline', 'Offline'),
+            text: nls.localizeByDefault('Offline'),
             tooltip: nls.localize('theia/localize/offlineTooltip', 'Cannot connect to backend.'),
             priority: 5000
         });

package/src/browser/menu/browser-menu-plugin.ts

@@ -143,7 +143,14 @@ export class DynamicMenuBarWidget extends MenuBarWidget {
     protected previousFocusedElement: HTMLElement | undefined;
 
     constructor() {
-        super();
+        // Disable Lumino's overflow menu feature. The feature has a bug where
+        // `onUpdateRequest` consumes a stale `_overflowIndex` (only recomputed at the
+        // end of the method), which causes a RangeError when the menu bar is rendered
+        // at zero width. Additionally, Theia's CSS does not constrain the menu bar's
+        // offsetWidth to the available space, so the overflow detection never triggers.
+        // See https://github.com/eclipse-theia/theia/issues/17352
+        // See https://github.com/jupyterlab/lumino/issues/811
+        super({ overflowMenuOptions: { isVisible: false } });
         // HACK we need to hook in on private method _openChildMenu. Don't do this at home!
         DynamicMenuBarWidget.prototype['_openChildMenu'] = () => {
             if (this.activeMenu instanceof DynamicMenuWidget) {

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/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;
+}