@theia/core 1.38.0 → 1.39.0-next.11

package/src/browser/frontend-application-module.ts

@@ -121,7 +121,7 @@ import {
     BreadcrumbsService,
     DefaultBreadcrumbRenderer,
 } from './breadcrumbs';
-import { RendererHost } from './widgets';
+import { DockPanel, RendererHost } from './widgets';
 import { TooltipService, TooltipServiceImpl } from './tooltip-service';
 import { BackendRequestService, RequestService, REQUEST_SERVICE_PATH } from '@theia/request';
 import { bindFrontendStopwatch, bindBackendStopwatch } from './performance';
@@ -190,7 +190,7 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
         const hoverService = container.get(HoverService);
         return new TabBarRenderer(contextMenuRenderer, tabBarDecoratorService, iconThemeService, selectionService, commandService, corePreferences, hoverService);
     });
-    bind(TheiaDockPanel.Factory).toFactory(({ container }) => options => {
+    bind(TheiaDockPanel.Factory).toFactory(({ container }) => (options?: DockPanel.IOptions) => {
         const corePreferences = container.get<CorePreferences>(CorePreferences);
         return new TheiaDockPanel(options, corePreferences);
     });

package/src/browser/keyboard/browser-keyboard-layout-provider.ts

@@ -59,7 +59,11 @@ export class BrowserKeyboardLayoutProvider implements KeyboardLayoutProvider, Ke
     }
 
     @postConstruct()
-    protected async initialize(): Promise<void> {
+    protected init(): void {
+        this.doInit();
+    }
+
+    protected async doInit(): Promise<void> {
         await this.loadState();
         const keyboard = (navigator as NavigatorExtension).keyboard;
         if (keyboard && keyboard.addEventListener) {

package/src/browser/preferences/injectable-preference-proxy.ts

@@ -48,7 +48,7 @@ export class InjectablePreferenceProxy<T extends Record<string, JSONValue>> impl
 
     @inject(PreferenceProxyOptions) protected readonly options: PreferenceProxyOptions;
     @inject(PreferenceService) protected readonly preferences: PreferenceService;
-    @inject(PreferenceProxySchema) protected readonly promisedSchema: PreferenceSchema | Promise<PreferenceSchema>;
+    @inject(PreferenceProxySchema) protected readonly promisedSchema: () => PreferenceSchema | Promise<PreferenceSchema>;
     @inject(PreferenceProxyFactory) protected readonly factory: PreferenceProxyFactory;
     protected toDispose = new DisposableCollection();
     protected _onPreferenceChangedEmitter: Emitter<PreferenceChangeEvent<T>> | undefined;
@@ -95,10 +95,11 @@ export class InjectablePreferenceProxy<T extends Record<string, JSONValue>> impl
 
     @postConstruct()
     protected init(): void {
-        if (this.promisedSchema instanceof Promise) {
-            this.promisedSchema.then(schema => this.schema = schema);
+        const schema = this.promisedSchema();
+        if (schema instanceof Promise) {
+            schema.then(resolvedSchema => this.schema = resolvedSchema);
         } else {
-            this.schema = this.promisedSchema;
+            this.schema = schema;
         }
     }
 

package/src/browser/saveable.ts

@@ -287,14 +287,16 @@ export class ShouldSaveDialog extends AbstractDialog<boolean> {
     constructor(widget: Widget) {
         super({
             title: nls.localizeByDefault('Do you want to save the changes you made to {0}?', widget.title.label || widget.title.caption)
+        }, {
+            node: widget.node.ownerDocument.createElement('div')
         });
 
-        const messageNode = document.createElement('div');
+        const messageNode = this.node.ownerDocument.createElement('div');
         messageNode.textContent = nls.localizeByDefault("Your changes will be lost if you don't save them.");
         messageNode.setAttribute('style', 'flex: 1 100%; padding-bottom: calc(var(--theia-ui-padding)*3);');
         this.contentNode.appendChild(messageNode);
-        this.dontSaveButton = this.appendDontSaveButton();
         this.appendCloseButton();
+        this.dontSaveButton = this.appendDontSaveButton();
         this.appendAcceptButton(nls.localizeByDefault('Save'));
     }
 

package/src/browser/secondary-window-handler.ts

@@ -23,6 +23,7 @@ import { Emitter } from '../common/event';
 import { SecondaryWindowService } from './window/secondary-window-service';
 import { KeybindingRegistry } from './keybinding';
 import { ColorApplicationContribution } from './color-application-contribution';
+import { StylingService } from './styling-service';
 
 /** Widget to be contained directly in a secondary window. */
 class SecondaryWindowRootWidget extends Widget {
@@ -50,8 +51,6 @@ class SecondaryWindowRootWidget extends Widget {
  */
 @injectable()
 export class SecondaryWindowHandler {
-    /** List of currently open secondary windows. Window references should be removed once the window is closed. */
-    protected readonly secondaryWindows: Window[] = [];
     /** List of widgets in secondary windows. */
     protected readonly _widgets: ExtractableWidget[] = [];
 
@@ -63,6 +62,9 @@ export class SecondaryWindowHandler {
     @inject(ColorApplicationContribution)
     protected colorAppContribution: ColorApplicationContribution;
 
+    @inject(StylingService)
+    protected stylingService: StylingService;
+
     protected readonly onDidAddWidgetEmitter = new Emitter<Widget>();
     /** Subscribe to get notified when a widget is added to this handler, i.e. the widget was moved to an secondary window . */
     readonly onDidAddWidget = this.onDidAddWidgetEmitter.event;
@@ -95,33 +97,6 @@ export class SecondaryWindowHandler {
             return;
         }
         this.applicationShell = shell;
-
-        // Set up messaging with secondary windows
-        window.addEventListener('message', (event: MessageEvent) => {
-            console.trace('Message on main window', event);
-            if (event.data.fromSecondary) {
-                console.trace('Message comes from secondary window');
-                return;
-            }
-            if (event.data.fromMain) {
-                console.trace('Message has mainWindow marker, therefore ignore it');
-                return;
-            }
-
-            // Filter setImmediate messages. Do not forward because these come in with very high frequency.
-            // They are not needed in secondary windows because these messages are just a work around
-            // to make setImmediate work in the main window: https://developer.mozilla.org/en-US/docs/Web/API/Window/setImmediate
-            if (typeof event.data === 'string' && event.data.startsWith('setImmediate')) {
-                return;
-            }
-
-            console.trace('Delegate main window message to secondary windows', event);
-            this.secondaryWindows.forEach(secondaryWindow => {
-                if (!secondaryWindow.window.closed) {
-                    secondaryWindow.window.postMessage({ ...event.data, fromMain: true }, '*');
-                }
-            });
-        });
     }
 
     /**
@@ -139,21 +114,13 @@ export class SecondaryWindowHandler {
             return;
         }
 
-        const newWindow = this.secondaryWindowService.createSecondaryWindow(closed => {
-            this.applicationShell.closeWidget(widget.id);
-            const extIndex = this.secondaryWindows.indexOf(closed);
-            if (extIndex > -1) {
-                this.secondaryWindows.splice(extIndex, 1);
-            }
-        });
+        const newWindow = this.secondaryWindowService.createSecondaryWindow(widget, this.applicationShell);
 
         if (!newWindow) {
             this.messageService.error('The widget could not be moved to a secondary window because the window creation failed. Please make sure to allow popups.');
             return;
         }
 
-        this.secondaryWindows.push(newWindow);
-
         const mainWindowTitle = document.title;
         newWindow.onload = () => {
             this.keybindings.registerEventListeners(newWindow);
@@ -168,6 +135,7 @@ export class SecondaryWindowHandler {
                 return;
             }
             const unregisterWithColorContribution = this.colorAppContribution.registerWindow(newWindow);
+            const unregisterWithStylingService = this.stylingService.registerWindow(newWindow);
 
             widget.secondaryWindow = newWindow;
             const rootWidget = new SecondaryWindowRootWidget();
@@ -182,6 +150,7 @@ export class SecondaryWindowHandler {
             // Close the window if the widget is disposed, e.g. by a command closing all widgets.
             widget.disposed.connect(() => {
                 unregisterWithColorContribution.dispose();
+                unregisterWithStylingService.dispose();
                 this.removeWidget(widget);
                 if (!newWindow.closed) {
                     newWindow.close();

package/src/browser/styling-service.ts

@@ -21,6 +21,7 @@ import { ColorRegistry } from './color-registry';
 import { DecorationStyle } from './decoration-style';
 import { FrontendApplicationContribution } from './frontend-application';
 import { ThemeService } from './theming';
+import { Disposable } from '../common';
 
 export const StylingParticipant = Symbol('StylingParticipant');
 
@@ -40,8 +41,7 @@ export interface CssStyleCollector {
 
 @injectable()
 export class StylingService implements FrontendApplicationContribution {
-
-    protected cssElement = DecorationStyle.createStyleElement('contributedColorTheme');
+    protected cssElements = new Map<Window, HTMLStyleElement>();
 
     @inject(ThemeService)
     protected readonly themeService: ThemeService;
@@ -53,11 +53,22 @@ export class StylingService implements FrontendApplicationContribution {
     protected readonly themingParticipants: ContributionProvider<StylingParticipant>;
 
     onStart(): void {
-        this.applyStyling(this.themeService.getCurrentTheme());
-        this.themeService.onDidColorThemeChange(e => this.applyStyling(e.newTheme));
+        this.registerWindow(window);
+        this.themeService.onDidColorThemeChange(e => this.applyStylingToWindows(e.newTheme));
+    }
+
+    registerWindow(win: Window): Disposable {
+        const cssElement = DecorationStyle.createStyleElement('contributedColorTheme', win.document.head);
+        this.cssElements.set(win, cssElement);
+        this.applyStyling(this.themeService.getCurrentTheme(), cssElement);
+        return Disposable.create(() => this.cssElements.delete(win));
+    }
+
+    protected applyStylingToWindows(theme: Theme): void {
+        this.cssElements.forEach(cssElement => this.applyStyling(theme, cssElement));
     }
 
-    protected applyStyling(theme: Theme): void {
+    protected applyStyling(theme: Theme, cssElement: HTMLStyleElement): void {
         const rules: string[] = [];
         const colorTheme: ColorTheme = {
             type: theme.type,
@@ -71,6 +82,6 @@ export class StylingService implements FrontendApplicationContribution {
             themingParticipant.registerThemeStyle(colorTheme, styleCollector);
         }
         const fullCss = rules.join('\n');
-        this.cssElement.innerText = fullCss;
+        cssElement.innerText = fullCss;
     }
 }

package/src/browser/widgets/widget.ts

@@ -115,6 +115,10 @@ export class BaseWidget extends Widget {
     protected scrollBar?: PerfectScrollbar;
     protected scrollOptions?: PerfectScrollbar.Options;
 
+    constructor(options?: Widget.IOptions) {
+        super(options);
+    }
+
     override dispose(): void {
         if (this.isDisposed) {
             return;

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

@@ -16,6 +16,9 @@
 import { inject, injectable, postConstruct } from 'inversify';
 import { SecondaryWindowService } from './secondary-window-service';
 import { WindowService } from './window-service';
+import { ExtractableWidget } from '../widgets';
+import { ApplicationShell } from '../shell';
+import { Saveable } from '../saveable';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
@@ -37,6 +40,33 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
 
     @postConstruct()
     init(): void {
+        // Set up messaging with secondary windows
+        window.addEventListener('message', (event: MessageEvent) => {
+            console.trace('Message on main window', event);
+            if (event.data.fromSecondary) {
+                console.trace('Message comes from secondary window');
+                return;
+            }
+            if (event.data.fromMain) {
+                console.trace('Message has mainWindow marker, therefore ignore it');
+                return;
+            }
+
+            // Filter setImmediate messages. Do not forward because these come in with very high frequency.
+            // They are not needed in secondary windows because these messages are just a work around
+            // to make setImmediate work in the main window: https://developer.mozilla.org/en-US/docs/Web/API/Window/setImmediate
+            if (typeof event.data === 'string' && event.data.startsWith('setImmediate')) {
+                return;
+            }
+
+            console.trace('Delegate main window message to secondary windows', event);
+            this.secondaryWindows.forEach(secondaryWindow => {
+                if (!secondaryWindow.window.closed) {
+                    secondaryWindow.window.postMessage({ ...event.data, fromMain: true }, '*');
+                }
+            });
+        });
+
         // Close all open windows when the main window is closed.
         this.windowService.onUnload(() => {
             // Iterate backwards because calling window.close might remove the window from the array
@@ -46,33 +76,52 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         });
     }
 
-    createSecondaryWindow(onClose?: (closedWin: Window) => void): Window | undefined {
-        const win = this.doCreateSecondaryWindow(onClose);
+    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
+        const win = this.doCreateSecondaryWindow(widget, shell);
         if (win) {
             this.secondaryWindows.push(win);
+            win.addEventListener('close', () => {
+                const extIndex = this.secondaryWindows.indexOf(win);
+                if (extIndex > -1) {
+                    this.secondaryWindows.splice(extIndex, 1);
+                };
+            });
         }
         return win;
     }
 
-    protected doCreateSecondaryWindow(onClose?: (closedWin: Window) => void): Window | undefined {
-        const win = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), 'popup');
-        if (win) {
-            // Add the unload listener after the dom content was loaded because otherwise the unload listener is called already on open in some browsers (e.g. Chrome).
-            win.addEventListener('DOMContentLoaded', () => {
-                win.addEventListener('unload', () => {
-                    this.handleWindowClosed(win, onClose);
-                });
-            });
+    protected findWindow<T>(windowName: string): Window | undefined {
+        for (const w of this.secondaryWindows) {
+            if (w.name === windowName) {
+                return w;
+            }
         }
-        return win ?? undefined;
+        return undefined;
     }
 
-    protected handleWindowClosed(win: Window, onClose?: (closedWin: Window) => void): void {
-        const extIndex = this.secondaryWindows.indexOf(win);
-        if (extIndex > -1) {
-            this.secondaryWindows.splice(extIndex, 1);
-        };
-        onClose?.(win);
+    protected doCreateSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
+        const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), 'popup') ?? undefined;
+        if (newWindow) {
+            newWindow.addEventListener('DOMContentLoaded', () => {
+                newWindow.addEventListener('beforeunload', evt => {
+                    const saveable = Saveable.get(widget);
+                    const wouldLoseState = !!saveable && saveable.dirty && saveable.autoSave === 'off';
+                    if (wouldLoseState) {
+                        evt.returnValue = '';
+                        evt.preventDefault();
+                        return 'non-empty';
+                    }
+                }, { capture: true });
+
+                newWindow.addEventListener('close', () => {
+                    const saveable = Saveable.get(widget);
+                    shell.closeWidget(widget.id, {
+                        save: !!saveable && saveable.dirty && saveable.autoSave !== 'off'
+                    });
+                });
+            });
+        }
+        return newWindow;
     }
 
     focus(win: Window): void {

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

@@ -14,6 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { ApplicationShell } from '../shell';
+import { ExtractableWidget } from '../widgets';
+
 export const SecondaryWindowService = Symbol('SecondaryWindowService');
 
 /**
@@ -29,7 +32,7 @@ export interface SecondaryWindowService {
      * @param onClose optional callback that is invoked when the secondary window is closed
      * @returns the created window or `undefined` if it could not be created
      */
-    createSecondaryWindow(onClose?: (win: Window) => void): Window | undefined;
+    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined;
 
     /** Handles focussing the given secondary window in the browser and on Electron. */
     focus(win: Window): void;

package/src/common/logger.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable } from 'inversify';
+import { inject, injectable, postConstruct } from 'inversify';
 import { LoggerWatcher } from './logger-watcher';
 import { ILoggerServer, LogLevel, ConsoleLogger, rootLoggerName } from './logger-protocol';
 
@@ -235,30 +235,28 @@ export class Logger implements ILogger {
     /* A promise resolved when the logger has been created by the backend.  */
     protected created: Promise<void>;
 
-    /**
-     * Build a new Logger.
-     */
-    constructor(
-        @inject(ILoggerServer) protected readonly server: ILoggerServer,
-        @inject(LoggerWatcher) protected readonly loggerWatcher: LoggerWatcher,
-        @inject(LoggerFactory) protected readonly factory: LoggerFactory,
-        @inject(LoggerName) protected name: string) {
+    @inject(ILoggerServer) protected readonly server: ILoggerServer;
+    @inject(LoggerWatcher) protected readonly loggerWatcher: LoggerWatcher;
+    @inject(LoggerFactory) protected readonly factory: LoggerFactory;
+    @inject(LoggerName) protected name: string;
 
-        if (name !== rootLoggerName) {
+    @postConstruct()
+    protected init(): void {
+        if (this.name !== rootLoggerName) {
             /* Creating a child logger.  */
-            this.created = server.child(name);
+            this.created = this.server.child(this.name);
         } else {
             /* Creating the root logger (it already exists at startup).  */
             this.created = Promise.resolve();
         }
 
         /* Fetch the log level so it's cached in the frontend.  */
-        this._logLevel = this.created.then(_ => this.server.getLogLevel(name));
+        this._logLevel = this.created.then(_ => this.server.getLogLevel(this.name));
 
         /* Update the log level if it changes in the backend. */
-        loggerWatcher.onLogLevelChanged(event => {
+        this.loggerWatcher.onLogLevelChanged(event => {
             this.created.then(() => {
-                if (event.loggerName === name) {
+                if (event.loggerName === this.name) {
                     this._logLevel = Promise.resolve(event.newLogLevel);
                 }
             });

package/src/common/message-rpc/rpc-message-encoder.ts

@@ -51,7 +51,7 @@ export interface RequestMessage {
 
 export interface NotificationMessage {
     type: RpcMessageType.Notification;
-    id: number;
+    id?: number;
     method: string;
     args: any[];
 }
@@ -111,7 +111,7 @@ export interface RpcMessageDecoder {
 export interface RpcMessageEncoder {
     cancel(buf: WriteBuffer, requestId: number): void;
 
-    notification(buf: WriteBuffer, requestId: number, method: string, args: any[]): void
+    notification(buf: WriteBuffer, method: string, args: any[], id?: number): void
 
     request(buf: WriteBuffer, requestId: number, method: string, args: any[]): void
 
@@ -130,8 +130,8 @@ export class MsgPackMessageEncoder implements RpcMessageEncoder {
     cancel(buf: WriteBuffer, requestId: number): void {
         this.encode<CancelMessage>(buf, { type: RpcMessageType.Cancel, id: requestId });
     }
-    notification(buf: WriteBuffer, requestId: number, method: string, args: any[]): void {
-        this.encode<NotificationMessage>(buf, { type: RpcMessageType.Notification, id: requestId, method, args });
+    notification(buf: WriteBuffer, method: string, args: any[], id?: number): void {
+        this.encode<NotificationMessage>(buf, { type: RpcMessageType.Notification, method, args, id });
     }
     request(buf: WriteBuffer, requestId: number, method: string, args: any[]): void {
         this.encode<RequestMessage>(buf, { type: RpcMessageType.Request, id: requestId, method, args });

package/src/common/message-rpc/rpc-protocol.ts

@@ -77,7 +77,11 @@ export class RpcProtocol {
         this.encoder = options.encoder ?? new MsgPackMessageEncoder();
         this.decoder = options.decoder ?? new MsgPackMessageDecoder();
         this.toDispose.push(this.onNotificationEmitter);
-        channel.onClose(() => this.toDispose.dispose());
+        channel.onClose(event => {
+            this.pendingRequests.forEach(pending => pending.reject(new Error(event.reason)));
+            this.pendingRequests.clear();
+            this.toDispose.dispose();
+        });
         this.toDispose.push(channel.onMessage(readBuffer => this.handleMessage(this.decoder.parse(readBuffer()))));
         this.mode = options.mode ?? 'default';
 
@@ -98,7 +102,7 @@ export class RpcProtocol {
                     return;
                 }
                 case RpcMessageType.Notification: {
-                    this.handleNotify(message.id, message.method, message.args);
+                    this.handleNotify(message.method, message.args, message.id);
                     return;
                 }
             }
@@ -179,7 +183,7 @@ export class RpcProtocol {
         }
 
         const output = this.channel.getWriteBuffer();
-        this.encoder.notification(output, this.nextMessageId++, method, args);
+        this.encoder.notification(output, method, args, this.nextMessageId++);
         output.commit();
     }
 
@@ -226,7 +230,7 @@ export class RpcProtocol {
         }
     }
 
-    protected async handleNotify(id: number, method: string, args: any[]): Promise<void> {
+    protected async handleNotify(method: string, args: any[], id?: number): Promise<void> {
         if (this.toDispose.disposed) {
             return;
         }

package/src/common/messaging/proxy-factory.ts

@@ -23,6 +23,7 @@ import { Emitter, Event } from '../event';
 import { Channel } from '../message-rpc/channel';
 import { RequestHandler, RpcProtocol } from '../message-rpc/rpc-protocol';
 import { ConnectionHandler } from './handler';
+import { Deferred } from '../promise-util';
 
 export type JsonRpcServer<Client> = Disposable & {
     /**
@@ -55,11 +56,11 @@ export class JsonRpcConnectionHandler<T extends object> implements ConnectionHan
     }
 }
 /**
- * Factory for creating a new {@link RpcConnection} for a given chanel and {@link RequestHandler}.
+ * Factory for creating a new {@link RpcProtocol} for a given chanel and {@link RequestHandler}.
  */
-export type RpcConnectionFactory = (channel: Channel, requestHandler: RequestHandler) => RpcProtocol;
+export type RpcProtocolFactory = (channel: Channel, requestHandler: RequestHandler) => RpcProtocol;
 
-const defaultRPCConnectionFactory: RpcConnectionFactory = (channel, requestHandler) => new RpcProtocol(channel, requestHandler);
+const defaultRpcProtocolFactory: RpcProtocolFactory = (channel, requestHandler) => new RpcProtocol(channel, requestHandler);
 
 /**
  * Factory for JSON-RPC proxy objects.
@@ -109,8 +110,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
     protected readonly onDidOpenConnectionEmitter = new Emitter<void>();
     protected readonly onDidCloseConnectionEmitter = new Emitter<void>();
 
-    protected connectionPromiseResolve: (connection: RpcProtocol) => void;
-    protected connectionPromise: Promise<RpcProtocol>;
+    protected rpcDeferred: Deferred<RpcProtocol>;
 
     /**
      * Build a new JsonRpcProxyFactory.
@@ -118,16 +118,14 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * @param target - The object to expose to JSON-RPC methods calls.  If this
      *   is omitted, the proxy won't be able to handle requests, only send them.
      */
-    constructor(public target?: any, protected rpcConnectionFactory = defaultRPCConnectionFactory) {
+    constructor(public target?: any, protected rpcProtocolFactory = defaultRpcProtocolFactory) {
         this.waitForConnection();
     }
 
     protected waitForConnection(): void {
-        this.connectionPromise = new Promise(resolve =>
-            this.connectionPromiseResolve = resolve
-        );
-        this.connectionPromise.then(connection => {
-            connection.channel.onClose(() => {
+        this.rpcDeferred = new Deferred<RpcProtocol>();
+        this.rpcDeferred.promise.then(protocol => {
+            protocol.channel.onClose(() => {
                 this.onDidCloseConnectionEmitter.fire(undefined);
                 // Wait for connection in case the backend reconnects
                 this.waitForConnection();
@@ -143,10 +141,10 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * response.
      */
     listen(channel: Channel): void {
-        const connection = this.rpcConnectionFactory(channel, (meth, args) => this.onRequest(meth, ...args));
-        connection.onNotification(event => this.onNotification(event.method, ...event.args));
+        const protocol = this.rpcProtocolFactory(channel, (meth, args) => this.onRequest(meth, ...args));
+        protocol.onNotification(event => this.onNotification(event.method, ...event.args));
 
-        this.connectionPromiseResolve(connection);
+        this.rpcDeferred.resolve(protocol);
     }
 
     /**
@@ -241,11 +239,15 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
         if (p === 'onDidCloseConnection') {
             return this.onDidCloseConnectionEmitter.event;
         }
+        if (p === 'then') {
+            // Prevent inversify from identifying this proxy as a promise object.
+            return undefined;
+        }
         const isNotify = this.isNotification(p);
         return (...args: any[]) => {
             const method = p.toString();
             const capturedError = new Error(`Request '${method}' failed`);
-            return this.connectionPromise.then(connection =>
+            return this.rpcDeferred.promise.then(connection =>
                 new Promise<void>((resolve, reject) => {
                     try {
                         if (isNotify) {

package/src/common/performance/stopwatch.ts

@@ -50,7 +50,7 @@ export abstract class Stopwatch {
     @inject(ILogger)
     protected readonly logger: ILogger;
 
-    protected constructor(protected readonly defaultLogOptions: LogOptions) {
+    constructor(protected readonly defaultLogOptions: LogOptions) {
         if (!defaultLogOptions.defaultLogLevel) {
             defaultLogOptions.defaultLogLevel = DEFAULT_LOG_LEVEL;
         }

package/src/electron-browser/keyboard/electron-keyboard-layout-change-notifier.ts

@@ -32,7 +32,7 @@ export class ElectronKeyboardLayoutChangeNotifier implements KeyboardLayoutChang
     }
 
     @postConstruct()
-    protected initialize(): void {
+    protected init(): void {
         window.electronTheiaCore.onKeyboardLayoutChanged((newLayout: NativeKeyboardLayout) => this.nativeLayoutChanged.fire(newLayout));
     }
 

package/src/electron-browser/menu/electron-context-menu-renderer.ts

@@ -90,7 +90,11 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
     }
 
     @postConstruct()
-    protected async init(): Promise<void> {
+    protected init(): void {
+        this.doInit();
+    }
+
+    protected async doInit(): Promise<void> {
         this.useNativeStyle = await window.electronTheiaCore.getTitleBarStyleAtStartup() === 'native';
     }