@theia/core 1.70.0-next.6 → 1.70.0-next.61

package/src/common/quick-pick-service.ts

@@ -19,6 +19,7 @@ import { Event } from './event';
 import { KeySequence } from './keys';
 import { CancellationToken } from './cancellation';
 import { Severity } from './severity';
+import { findSubstringIndex, matchRank } from './fuzzy-match-utils';
 
 export const quickPickServicePath = '/services/quickPick';
 export const QuickPickService = Symbol('QuickPickService');
@@ -92,6 +93,26 @@ export interface QuickPickValue<V> extends QuickPickItem {
     value: V
 }
 
+/**
+ * Specifies the location where a {@link QuickInputButton} should be rendered.
+ */
+export enum QuickInputButtonLocation {
+    /**
+     * The button is rendered in the title bar.
+     */
+    Title = 1,
+
+    /**
+     * The button is rendered inline to the right of the input box.
+     */
+    Inline = 2,
+
+    /**
+     * The button is rendered at the far end inside the input box.
+     */
+    Input = 3
+}
+
 export interface QuickInputButton {
     iconClass?: string;
     tooltip?: string;
@@ -101,9 +122,8 @@ export interface QuickInputButton {
     alwaysVisible?: boolean;
     /**
      * The location where the button should be rendered.
-     * @monaco-uplift: consider using a typed enum matching Monaco's QuickInputButtonLocation instead of number.
      */
-    location?: number;
+    location?: QuickInputButtonLocation;
     /**
      * When present, indicates that the button is a toggle button.
      */
@@ -303,24 +323,52 @@ export function filterItems(items: QuickPickItemOrSeparator[], filter: string):
         return items;
     }
 
-    const filteredItems: QuickPickItemOrSeparator[] = [];
+    function matchesFilter(item: QuickPickItem): boolean {
+        return fuzzy.test(filter, item.label) ||
+            (!!item.description && fuzzy.test(filter, item.description)) ||
+            (!!item.detail && fuzzy.test(filter, item.detail));
+    }
+
+    function itemMatchRank(item: QuickPickItem): number {
+        return Math.min(
+            matchRank(item.label, filter),
+            item.description ? matchRank(item.description, filter) : 2,
+            item.detail ? matchRank(item.detail, filter) : 2
+        );
+    }
+
+    // Process items in separator groups, sorted by match rank within each group.
+    const result: QuickPickItemOrSeparator[] = [];
+    let currentSeparator: QuickPickSeparator | undefined;
+    let groupMatches: { item: QuickPickItem; rank: number }[] = [];
+
+    const flushGroup = (): void => {
+        if (groupMatches.length > 0) {
+            if (currentSeparator) {
+                result.push(currentSeparator);
+            }
+            groupMatches.sort((a, b) => a.rank - b.rank);
+            result.push(...groupMatches.map(m => m.item));
+        }
+        groupMatches = [];
+    };
+
     for (const item of items) {
         if (item.type === 'separator') {
-            filteredItems.push(item);
-        } else if (
-            fuzzy.test(filter, item.label) ||
-            (item.description && fuzzy.test(filter, item.description)) ||
-            (item.detail && fuzzy.test(filter, item.detail))
-        ) {
+            flushGroup();
+            currentSeparator = item;
+        } else if (matchesFilter(item)) {
             item.highlights = {
                 label: findMatches(item.label, filter),
                 description: item.description ? findMatches(item.description, filter) : undefined,
                 detail: item.detail ? findMatches(item.detail, filter) : undefined
             };
-            filteredItems.push(item);
+            groupMatches.push({ item, rank: itemMatchRank(item) });
         }
     }
-    return filteredItems;
+    flushGroup();
+
+    return result;
 }
 
 /**
@@ -337,6 +385,12 @@ export function findMatches(word: string, pattern: string): Array<{ start: numbe
         return undefined;
     }
 
+    // Prefer a contiguous substring highlight over scattered fuzzy character highlights.
+    const substringIndex = findSubstringIndex(word, pattern);
+    if (substringIndex !== -1) {
+        return [{ start: substringIndex, end: substringIndex + pattern.length }];
+    }
+
     const delimiter = '\u0000'; // null byte that shouldn't appear in the input and is used to denote matches.
     const matchResult = fuzzy.match(pattern.replace(/\u0000/gu, ''), word, { pre: delimiter, post: delimiter });
     if (!matchResult) {

package/src/common/uri.ts

@@ -22,7 +22,7 @@ export class URI {
     public static fromComponents(components: UriComponents): URI;
     public static fromComponents(components: undefined): undefined;
     public static fromComponents(components: UriComponents | undefined): URI | undefined {
-        return components ? new URI(Uri.revive(components)) : undefined;
+        return components ? new URI(Uri.from(components)) : undefined;
     }
 
     public static fromFilePath(path: string): URI {

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -233,12 +233,10 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 }
             };
 
-            if (isOSX) {
-                const role = this.roleFor(menu.id);
-                if (role) {
-                    menuItem.role = role;
-                    delete menuItem.execute;
-                }
+            const role = this.roleFor(menu.id);
+            if (role) {
+                menuItem.role = role;
+                delete menuItem.execute;
             }
             parentItems.push(menuItem);
         }

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -26,7 +26,7 @@ import {
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { FrontendApplicationStateService, FrontendApplicationState } from '../../browser/frontend-application-state';
 import { FrontendApplicationConfigProvider } from '../../browser/frontend-application-config-provider';
-import { ZoomLevel } from '../../electron-common/electron-window-preferences';
+import { PREF_WINDOW_ZOOM_LEVEL, ZoomLevel } from '../../electron-common/electron-window-preferences';
 import { BrowserMenuBarContribution } from '../../browser/menu/browser-menu-plugin';
 import { WindowService } from '../../browser/window/window-service';
 import { WindowTitleService } from '../../browser/window/window-title-service';
@@ -316,7 +316,7 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
                     zoomLevel = ZoomLevel.MAX;
                     return;
                 };
-                this.preferenceService.set('window.zoomLevel', zoomLevel, PreferenceScope.User);
+                this.preferenceService.set(PREF_WINDOW_ZOOM_LEVEL, zoomLevel, PreferenceScope.User);
             }
         });
         registry.registerCommand(ElectronCommands.ZOOM_OUT, {
@@ -328,11 +328,11 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
                     zoomLevel = ZoomLevel.MIN;
                     return;
                 };
-                this.preferenceService.set('window.zoomLevel', zoomLevel, PreferenceScope.User);
+                this.preferenceService.set(PREF_WINDOW_ZOOM_LEVEL, zoomLevel, PreferenceScope.User);
             }
         });
         registry.registerCommand(ElectronCommands.RESET_ZOOM, {
-            execute: () => this.preferenceService.set('window.zoomLevel', ZoomLevel.DEFAULT, PreferenceScope.User)
+            execute: () => this.preferenceService.set(PREF_WINDOW_ZOOM_LEVEL, ZoomLevel.DEFAULT, PreferenceScope.User)
         });
 
         registry.registerCommand(ElectronCommands.TOGGLE_FULL_SCREEN, {

package/src/electron-browser/messaging/electron-local-ws-connection-source.ts

@@ -18,14 +18,16 @@ import { injectable } from 'inversify';
 import { Endpoint } from '../../browser/endpoint';
 import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 
+export const LOCAL_PORT_PARAM = 'localPort';
 export function getLocalPort(): string | undefined {
     const params = new URLSearchParams(location.search);
-    return params.get('localPort') ?? undefined;
+    return params.get(LOCAL_PORT_PARAM) ?? undefined;
 }
 
+export const CURRENT_PORT_PARAM = 'port';
 export function getCurrentPort(): string | undefined {
     const params = new URLSearchParams(location.search);
-    return params.get('port') ?? undefined;
+    return params.get(CURRENT_PORT_PARAM) ?? undefined;
 }
 
 @injectable()

package/src/electron-browser/preload.ts

@@ -207,8 +207,8 @@ const api: TheiaCoreAPI = {
         return ipcRenderer.invoke(CHANNEL_GET_ZOOM_LEVEL);
     },
 
-    setZoomLevel: function (desired: number): void {
-        ipcRenderer.send(CHANNEL_SET_ZOOM_LEVEL, desired);
+    setZoomLevel: function (desired: number, windowName?: string): void {
+        ipcRenderer.send(CHANNEL_SET_ZOOM_LEVEL, desired, windowName);
     },
     isFullScreenable: function (): boolean {
         return ipcRenderer.sendSync(CHANNEL_IS_FULL_SCREENABLE);

package/src/electron-browser/style/window-zoom-action-bar.css

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+.window-zoom-action-bar {
+    display: flex;
+    align-items: center;
+    gap: calc(var(--theia-ui-padding) / 3);
+    line-height: 1;
+}
+
+.window-zoom-action-bar .codicon {
+    font-size: inherit;
+}
+
+.window-zoom-display {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 1.5em;
+    padding: calc(var(--theia-ui-padding) / 3);
+    cursor: default;
+    user-select: none;
+}
+
+.window-zoom-button {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: calc(var(--theia-ui-padding) / 3);
+    border-radius: calc(var(--theia-ui-padding) / 2);
+    white-space: nowrap;
+}
+
+.window-zoom-button:hover {
+    background-color: var(--theia-toolbar-hoverBackground);
+}
+
+.window-zoom-button:focus-visible {
+    outline: 1px solid var(--theia-focusBorder);
+}
+
+#status-bar-window-zoom-status {
+    padding-inline: calc(var(--theia-ui-padding) * 2 / 3);
+}

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

@@ -14,14 +14,41 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 import { DefaultSecondaryWindowService } from '../../browser/window/default-secondary-window-service';
 import { ApplicationShell, ExtractableWidget } from '../../browser';
 import { ElectronWindowService } from './electron-window-service';
 import { Deferred, timeout } from '../../common/promise-util';
+import { ElectronWindowPreferences, PREF_WINDOW_ZOOM_LEVEL } from '../../electron-common/electron-window-preferences';
 
 @injectable()
 export class ElectronSecondaryWindowService extends DefaultSecondaryWindowService {
+
+    @inject(ElectronWindowPreferences)
+    protected readonly electronWindowPreferences: ElectronWindowPreferences;
+
+    @postConstruct()
+    override init(): void {
+        super.init();
+        this.electronWindowPreferences.ready.then(() => {
+            const initialZoomLevel = this.electronWindowPreferences.get(PREF_WINDOW_ZOOM_LEVEL);
+            this.updateWindowZoomLevel(initialZoomLevel);
+
+            this.electronWindowPreferences.onPreferenceChanged(e => {
+                if (e.preferenceName === PREF_WINDOW_ZOOM_LEVEL) {
+                    const zoomLevel = this.electronWindowPreferences.get(PREF_WINDOW_ZOOM_LEVEL, 0);
+                    this.updateWindowZoomLevel(zoomLevel);
+                }
+            });
+        });
+    }
+
+    protected async updateWindowZoomLevel(zoomLevel: number): Promise<void> {
+        this.secondaryWindows.forEach((win: Window) => {
+            window.electronTheiaCore.setZoomLevel(zoomLevel, win.name);
+        });
+    }
+
     override focus(win: Window): void {
         window.electronTheiaCore.focusWindow(win.name);
     }
@@ -50,6 +77,10 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
         window.electronTheiaCore.setMenuBarVisible(false, newWindow.name);
         window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell, newWindow));
 
+        // Apply current zoom level to newly created secondary window
+        const currentZoomLevel = this.electronWindowPreferences.get(PREF_WINDOW_ZOOM_LEVEL, 0);
+        window.electronTheiaCore.setZoomLevel(currentZoomLevel, newWindow.name);
+
         // Below code may be used to debug contents of secondary window
         // window.electronTheiaCore.openDevToolsForWindow(newWindow.name);
     }

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

@@ -32,6 +32,8 @@ import { ExternalAppOpenHandler } from './external-app-open-handler';
 import { ElectronUriHandlerContribution } from '../electron-uri-handler';
 import { bindRootContributionProvider } from '../../common';
 import { WindowTitleContribution } from '../../browser/window/window-title-service';
+import { WindowZoomStatusBarItem } from './window-zoom-status-bar-item';
+import '../../../src/electron-browser/style/window-zoom-action-bar.css';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -48,4 +50,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(ExternalAppOpenHandler);
     bindRootContributionProvider(bind, WindowTitleContribution);
+    bind(WindowZoomStatusBarItem).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(WindowZoomStatusBarItem);
 });

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

@@ -15,10 +15,10 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct } from 'inversify';
-import { NewWindowOptions, WindowSearchParams } from '../../common/window';
+import { NewWindowOptions } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
-import { ElectronWindowPreferences } from '../../electron-common/electron-window-preferences';
+import { ElectronWindowPreferences, PREF_WINDOW_ZOOM_LEVEL } from '../../electron-common/electron-window-preferences';
 import { ConnectionCloseService } from '../../common/messaging/connection-management';
 import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 import { WindowReloadOptions } from '../../browser/window/window-service';
@@ -57,8 +57,12 @@ export class ElectronWindowService extends DefaultWindowService {
         return undefined;
     }
 
-    override openNewDefaultWindow(params?: WindowSearchParams): void {
-        this.delegate.openNewDefaultWindow(params);
+    override async openNewDefaultWindow(params?: WindowReloadOptions): Promise<number> {
+        return this.delegate.openNewDefaultWindow(params?.search);
+    }
+
+    override closeWindow(windowId: number): void {
+        this.delegate.closeWindow(windowId);
     }
 
     override focus(): void {
@@ -68,7 +72,7 @@ export class ElectronWindowService extends DefaultWindowService {
     protected init(): void {
         // Update the default zoom level on startup when the preferences event is fired.
         this.electronWindowPreferences.onPreferenceChanged(e => {
-            if (e.preferenceName === 'window.zoomLevel') {
+            if (e.preferenceName === PREF_WINDOW_ZOOM_LEVEL) {
                 this.updateWindowZoomLevel();
             }
         });
@@ -94,7 +98,7 @@ export class ElectronWindowService extends DefaultWindowService {
      * Updates the window zoom level based on the preference value.
      */
     protected async updateWindowZoomLevel(): Promise<void> {
-        const preferredZoomLevel = this.electronWindowPreferences['window.zoomLevel'];
+        const preferredZoomLevel = this.electronWindowPreferences[PREF_WINDOW_ZOOM_LEVEL];
         if (await window.electronTheiaCore.getZoomLevel() !== preferredZoomLevel) {
             window.electronTheiaCore.setZoomLevel(preferredZoomLevel);
         }
@@ -116,4 +120,3 @@ export class ElectronWindowService extends DefaultWindowService {
         }
     }
 }
-

package/src/electron-browser/window/window-zoom-action-bar.tsx

@@ -0,0 +1,115 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+import { createRoot } from 'react-dom/client';
+import * as React from '../../../shared/react';
+import { ACTION_ITEM, codicon, CommonCommands, KeybindingRegistry } from '../../browser';
+import { Command, CommandRegistry, nls } from '../../common';
+import { PREF_WINDOW_ZOOM_LEVEL, ZoomLevel } from '../../electron-common/electron-window-preferences';
+import { ElectronCommands } from '../menu/electron-menu-contribution';
+
+export interface WindowZoomActionBarProps {
+    container: HTMLElement
+    zoomLevel: number;
+    commandRegistry: CommandRegistry;
+    keybindingRegistry: KeybindingRegistry;
+}
+
+export class WindowZoomActionBar extends React.Component<WindowZoomActionBarProps> {
+
+    protected getTitleWithKeybinding(command: Command): string {
+        const bindings = this.props.keybindingRegistry.getKeybindingsForCommand(command.id);
+        // Only consider the first active keybinding.
+        if (bindings.length) {
+            const binding = bindings.find(b => this.props.keybindingRegistry.isEnabledInScope(b, this.props.container));
+            if (binding) {
+                const accelerator = this.props.keybindingRegistry.acceleratorFor(binding, '+', true);
+                return `${command.label} (${accelerator})`;
+            }
+        }
+        return command.label!;
+    }
+
+    protected renderActionButton(command: Command, iconName?: string, commandArgs: unknown[] = []): React.ReactNode {
+        return (
+            <div
+                className={`${ACTION_ITEM} window-zoom-button`}
+                role='button'
+                tabIndex={0}
+                aria-label={command.label}
+                title={this.getTitleWithKeybinding(command)}
+                onClick={() => this.props.commandRegistry.executeCommand(command.id, ...commandArgs)}
+                onKeyDown={e => {
+                    if (e.key === 'Enter' || e.key === ' ') {
+                        e.preventDefault();
+                        this.props.commandRegistry.executeCommand(command.id, ...commandArgs);
+                    }
+                }}
+            >
+                {iconName ? <div className={codicon(iconName)}></div> : <div>{command.label}</div>}
+            </div>
+        );
+    }
+
+    protected renderZoomDisplay(): React.ReactNode {
+        const percentage = Math.round(100 * Math.pow(ZoomLevel.ZOOM_BASE, this.props.zoomLevel));
+        const zoomLevelText = nls.localizeByDefault('Zoom Level: {0} ({1}%)', this.props.zoomLevel.toString(), percentage.toString());
+        return (
+            <div
+                className='window-zoom-display'
+                role='status'
+                aria-live='polite'
+                aria-atomic='true'
+                aria-label={zoomLevelText}
+                title={zoomLevelText}
+            >
+                <div>{this.props.zoomLevel}</div>
+            </div>
+        );
+    }
+
+    override render(): React.ReactNode {
+        return (
+            <>
+                {this.renderActionButton(ElectronCommands.ZOOM_OUT, 'remove')}
+                {this.renderZoomDisplay()}
+                {this.renderActionButton(ElectronCommands.ZOOM_IN, 'plus')}
+                {this.renderActionButton(ElectronCommands.RESET_ZOOM)}
+                {this.renderActionButton(CommonCommands.OPEN_PREFERENCES, 'settings-gear', [PREF_WINDOW_ZOOM_LEVEL])}
+            </>
+        );
+    }
+}
+
+/**
+ * Helper function to render the WindowZoomActionBar React component into a DOM container element.
+ * This function can be called from a TypeScript file without JSX.
+ */
+export function renderWindowZoomActionBar(
+    container: HTMLElement,
+    zoomLevel: number,
+    commandRegistry: CommandRegistry,
+    keybindingRegistry: KeybindingRegistry,
+): void {
+    const root = createRoot(container);
+    root.render(
+        <WindowZoomActionBar
+            container={container}
+            zoomLevel={zoomLevel}
+            commandRegistry={commandRegistry}
+            keybindingRegistry={keybindingRegistry}
+        />
+    );
+}

package/src/electron-browser/window/window-zoom-status-bar-item.ts

@@ -0,0 +1,81 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+import { inject, injectable } from 'inversify';
+import { FrontendApplicationContribution, KeybindingRegistry, StatusBar, StatusBarAlignment } from '../../browser';
+import { CommandRegistry, nls, PreferenceService } from '../../common';
+import { PREF_WINDOW_ZOOM_LEVEL } from '../../electron-common/electron-window-preferences';
+import { renderWindowZoomActionBar } from './window-zoom-action-bar';
+
+@injectable()
+export class WindowZoomStatusBarItem implements FrontendApplicationContribution {
+
+    static readonly ID = 'window-zoom-status';
+
+    @inject(StatusBar)
+    protected readonly statusBar: StatusBar;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(CommandRegistry)
+    protected readonly commandRegistry: CommandRegistry;
+
+    @inject(KeybindingRegistry)
+    protected readonly keybindingRegistry: KeybindingRegistry;
+
+    onStart(): void {
+        this.preferenceService.ready.then(() => {
+            this.updateZoomStatusBarItem();
+
+            this.preferenceService.onPreferenceChanged(e => {
+                if (e.preferenceName === PREF_WINDOW_ZOOM_LEVEL) {
+                    this.updateZoomStatusBarItem();
+                }
+            });
+        });
+    }
+
+    protected updateZoomStatusBarItem(): void {
+        const zoomLevel = this.getZoomLevel();
+
+        if (zoomLevel === 0) {
+            // Hide the status bar item when zoom is at default level
+            this.statusBar.removeElement(WindowZoomStatusBarItem.ID);
+        } else {
+            this.statusBar.setElement(WindowZoomStatusBarItem.ID, {
+                name: nls.localizeByDefault('Window Zoom'),
+                text: zoomLevel > 0 ? '$(codicon-zoom-in)' : '$(codicon-zoom-out)',
+                alignment: StatusBarAlignment.RIGHT,
+                priority: 110,
+                tooltip: () => this.createTooltip(zoomLevel),
+                backgroundColor: 'var(--theia-statusBarItem-prominentBackground)',
+                color: 'var(--theia-statusBarItem-prominentForeground)'
+            });
+        }
+    }
+
+    protected getZoomLevel(): number {
+        return this.preferenceService.get(PREF_WINDOW_ZOOM_LEVEL, 0);
+    }
+
+    protected createTooltip(zoomLevel: number): HTMLElement {
+        const container = document.createElement('div');
+        container.className = 'window-zoom-action-bar';
+        renderWindowZoomActionBar(container, zoomLevel, this.commandRegistry, this.keybindingRegistry);
+        return container;
+    }
+}

package/src/electron-common/electron-api.ts

@@ -85,7 +85,7 @@ export interface TheiaCoreAPI {
     toggleDevTools(): void;
     openDevToolsForWindow(windowName: string): void;
     getZoomLevel(): Promise<number>;
-    setZoomLevel(desired: number): void;
+    setZoomLevel(desired: number, windowName?: string): void;
 
     isFullScreenable(): boolean; // TODO: this should really be async, since it blocks the renderer process
     isFullScreen(): boolean; // TODO: this should really be async, since it blocks the renderer process

package/src/electron-common/electron-main-window-service.ts

@@ -20,5 +20,6 @@ export const electronMainWindowServicePath = '/services/electron-window';
 export const ElectronMainWindowService = Symbol('ElectronMainWindowService');
 export interface ElectronMainWindowService {
     openNewWindow(url: string, options?: NewWindowOptions): undefined;
-    openNewDefaultWindow(params?: WindowSearchParams): void;
+    openNewDefaultWindow(params?: WindowSearchParams): Promise<number>;
+    closeWindow(windowId: number): void;
 }

package/src/electron-common/electron-window-preferences.ts

@@ -27,20 +27,28 @@ export namespace ZoomLevel {
     export const MAX = 9;
     // amount to increment or decrement the window zoom level.
     export const VARIATION = 0.5;
+    // Chromium's base for zoom factor calculation: zoomFactor = pow(ZOOM_BASE, zoomLevel)
+    // See https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/common/page/page_zoom.cc
+    export const ZOOM_BASE = 1.2;
 }
 
+export const PREF_WINDOW_ZOOM_LEVEL = 'window.zoomLevel';
+export const PREF_WINDOW_TITLE_BAR_STYLE = 'window.titleBarStyle';
+
 export const electronWindowPreferencesSchema: PreferenceSchema = {
     properties: {
-        'window.zoomLevel': {
-            'type': 'number',
-            'default': ZoomLevel.DEFAULT,
-            'minimum': ZoomLevel.MIN,
-            'maximum': ZoomLevel.MAX,
-            'scope': PreferenceScope.User,
-            // eslint-disable-next-line max-len
-            'description': nls.localizeByDefault("Adjust the default zoom level for all windows. Each increment above `0` (e.g. `1`) or below (e.g. `-1`) represents zooming `20%` larger or smaller. You can also enter decimals to adjust the zoom level with a finer granularity. See {0} for configuring if the 'Zoom In' and 'Zoom Out' commands apply the zoom level to all windows or only the active window.")
+        [PREF_WINDOW_ZOOM_LEVEL]: {
+            type: 'number',
+            default: ZoomLevel.DEFAULT,
+            minimum: ZoomLevel.MIN,
+            maximum: ZoomLevel.MAX,
+            scope: PreferenceScope.User,
+            markdownDescription: nls.localize('theia/core/window/zoomLevelPref',
+                'Adjust the default zoom level for all windows.\
+                Each increment of `0.5` above `0` (e.g. `0.5`) or below (e.g. `-0.5`) represents zooming approximately `10%` larger or smaller.\
+                You can also enter other decimal values to adjust the zoom level with a finer granularity.')
         },
-        'window.titleBarStyle': {
+        [PREF_WINDOW_TITLE_BAR_STYLE]: {
             type: 'string',
             enum: ['native', 'custom'],
             default: isWindows ? 'custom' : 'native',
@@ -52,8 +60,8 @@ export const electronWindowPreferencesSchema: PreferenceSchema = {
 };
 
 export class ElectronWindowConfiguration {
-    'window.zoomLevel': number;
-    'window.titleBarStyle': 'native' | 'custom';
+    [PREF_WINDOW_ZOOM_LEVEL]: number;
+    [PREF_WINDOW_TITLE_BAR_STYLE]: 'native' | 'custom';
 }
 
 export const ElectronWindowPreferenceContribution = Symbol('ElectronWindowPreferenceContribution');