@theia/core 1.29.0-next.9 → 1.29.0

package/src/common/preferences/preference-scope.spec.ts

@@ -0,0 +1,48 @@
+// *****************************************************************************
+// Copyright (C) 2022 TypeFox 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { PreferenceScope } from './preference-scope';
+
+describe('PreferenceScope', () => {
+
+    it('getScopes() should return numbers from broadest to narrowest', () => {
+        expect(PreferenceScope.getScopes()).deep.equal([0, 1, 2, 3]);
+    });
+
+    it('getReversedScopes() should return numbers from narrowest to broadest', () => {
+        expect(PreferenceScope.getReversedScopes()).deep.equal([3, 2, 1, 0]);
+    });
+
+    it('getScopeNames() should return the names of scopes broader than the current one', () => {
+        expect(PreferenceScope.getScopeNames(PreferenceScope.Workspace)).deep.equal(['Default', 'User', 'Workspace']);
+    });
+
+    it('is() returns whether a value is a preference scope', () => {
+        expect(PreferenceScope.is(PreferenceScope.Default)).to.be.true;
+        expect(PreferenceScope.is(PreferenceScope.User)).to.be.true;
+        expect(PreferenceScope.is(PreferenceScope.Workspace)).to.be.true;
+        expect(PreferenceScope.is(PreferenceScope.Folder)).to.be.true;
+        expect(PreferenceScope.is(0)).to.be.true;
+        expect(PreferenceScope.is(1)).to.be.true;
+        expect(PreferenceScope.is(2)).to.be.true;
+        expect(PreferenceScope.is(3)).to.be.true;
+        expect(PreferenceScope.is(4)).to.be.false;
+        expect(PreferenceScope.is(-1)).to.be.false;
+        expect(PreferenceScope.is({})).to.be.false;
+        expect(PreferenceScope.is('Default')).to.be.false;
+    });
+});

package/src/common/preferences/preference-scope.ts

@@ -14,8 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 export enum PreferenceScope {
     Default,
     User,
@@ -24,17 +22,15 @@ export enum PreferenceScope {
 }
 
 export namespace PreferenceScope {
-    export function is(scope: any): scope is PreferenceScope {
-        return typeof scope === 'number' && getScopes().findIndex(s => s === scope) >= 0;
+    export function is(scope: unknown): scope is PreferenceScope {
+        return typeof scope === 'number' && getScopes().includes(scope);
     }
 
     /**
      * @returns preference scopes from broadest to narrowest: Default -> Folder.
      */
     export function getScopes(): PreferenceScope[] {
-        return Object.keys(PreferenceScope)
-            .filter(k => typeof PreferenceScope[k as any] === 'string')
-            .map(v => <PreferenceScope>Number(v));
+        return Object.values(PreferenceScope).filter(nameOrIndex => !isNaN(Number(nameOrIndex))) as PreferenceScope[];
     }
 
     /**
@@ -46,12 +42,11 @@ export namespace PreferenceScope {
 
     export function getScopeNames(scope?: PreferenceScope): string[] {
         const names: string[] = [];
-        const allNames = Object.keys(PreferenceScope)
-            .filter(k => typeof PreferenceScope[k as any] === 'number');
+        const scopes = getScopes();
         if (scope) {
-            for (const name of allNames) {
-                if ((<any>PreferenceScope)[name] <= scope) {
-                    names.push(name);
+            for (const scopeIndex of scopes) {
+                if (scopeIndex <= scope) {
+                    names.push(PreferenceScope[scopeIndex]);
                 }
             }
         }

package/src/common/promise-util.ts

@@ -124,3 +124,7 @@ export function waitForEvent<T>(event: Event<T>, ms: number, thisArg?: any, disp
 
     });
 }
+
+export function isThenable<T>(obj: unknown): obj is Promise<T> {
+    return typeof obj === 'object' && !!obj && typeof (obj as Promise<unknown>).then === 'function';
+}

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

@@ -216,7 +216,7 @@ export interface InputOptions {
     placeHolder?: string;
     password?: boolean;
     ignoreFocusLost?: boolean;
-    validateInput?(input: string): Promise<string | null | undefined> | undefined;
+    validateInput?(input: string): Promise<string | { content: string; severity: number; }  | null | undefined> | undefined;
 }
 
 export interface QuickPickItemButtonEvent<T extends QuickPickItemOrSeparator> {

package/src/common/selection.ts

@@ -22,12 +22,11 @@ export interface UriSelection {
 
 export namespace UriSelection {
 
-    export function is(arg: Object | undefined): arg is UriSelection {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return typeof arg === 'object' && ('uri' in arg) && (<any>arg)['uri'] instanceof URI;
+    export function is(arg: unknown): arg is UriSelection {
+        return !!arg && typeof arg === 'object' && ('uri' in arg) && (arg as UriSelection).uri instanceof URI;
     }
 
-    export function getUri(selection: Object | undefined): URI | undefined {
+    export function getUri(selection: unknown): URI | undefined {
         if (is(selection)) {
             return selection.uri;
         }
@@ -37,7 +36,7 @@ export namespace UriSelection {
         return undefined;
     }
 
-    export function getUris(selection: Object | undefined): URI[] {
+    export function getUris(selection: unknown): URI[] {
         if (is(selection)) {
             return [selection.uri];
         }

package/src/electron-browser/messaging/electron-ipc-connection-provider.ts

@@ -19,9 +19,8 @@ import { injectable, interfaces } from 'inversify';
 import { JsonRpcProxy } from '../../common/messaging';
 import { AbstractConnectionProvider } from '../../common/messaging/abstract-connection-provider';
 import { THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
-import { Emitter, Event } from '../../common';
+import { AbstractChannel, Channel, Disposable, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
-import { Channel, MessageProvider } from '../../common/message-rpc/channel';
 
 export interface ElectronIpcOptions {
 }
@@ -42,23 +41,26 @@ export class ElectronIpcConnectionProvider extends AbstractConnectionProvider<El
     }
 
     protected createMainChannel(): Channel {
-        const onMessageEmitter = new Emitter<MessageProvider>();
-        ipcRenderer.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, (_event: ElectronEvent, data: Uint8Array) => {
-            onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
-        });
-        return {
-            close: () => Event.None,
-            getWriteBuffer: () => {
-                const writer = new Uint8ArrayWriteBuffer();
-                writer.onCommit(buffer =>
-                    ipcRenderer.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer)
-                );
-                return writer;
-            },
-            onClose: Event.None,
-            onError: Event.None,
-            onMessage: onMessageEmitter.event
-        };
+        return new ElectronIpcRendererChannel();
+    }
+
+}
+
+export class ElectronIpcRendererChannel extends AbstractChannel {
+
+    constructor() {
+        super();
+        const ipcMessageHandler = (_event: ElectronEvent, data: Uint8Array) => this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
+        ipcRenderer.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, ipcMessageHandler);
+        this.toDispose.push(Disposable.create(() => ipcRenderer.removeListener(THEIA_ELECTRON_IPC_CHANNEL_NAME, ipcMessageHandler)));
+    }
+
+    getWriteBuffer(): WriteBuffer {
+        const writer = new Uint8ArrayWriteBuffer();
+        writer.onCommit(buffer =>
+            ipcRenderer.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer)
+        );
+        return writer;
     }
 
 }

package/src/electron-main/electron-main-application.ts

@@ -500,7 +500,7 @@ export class ElectronMainApplication {
         app.on('window-all-closed', this.onWindowAllClosed.bind(this));
 
         ipcMain.on(TitleBarStyleChanged, ({ sender }, titleBarStyle: string) => {
-            this.useNativeWindowFrame = titleBarStyle === 'native';
+            this.useNativeWindowFrame = isOSX || titleBarStyle === 'native';
             const browserWindow = BrowserWindow.fromId(sender.id);
             if (browserWindow) {
                 this.saveWindowState(browserWindow);

package/src/electron-main/messaging/electron-messaging-contribution.ts

@@ -21,8 +21,8 @@ import { MessagingContribution } from '../../node/messaging/messaging-contributi
 import { ElectronConnectionHandler, THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
 import { ElectronMainApplicationContribution } from '../electron-main-application';
 import { ElectronMessagingService } from './electron-messaging-service';
-import { Channel, ChannelCloseEvent, ChannelMultiplexer, MessageProvider } from '../../common/message-rpc/channel';
-import { Emitter, Event, WriteBuffer } from '../../common';
+import { AbstractChannel, Channel, ChannelMultiplexer, MessageProvider } from '../../common/message-rpc/channel';
+import { Emitter, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
 
 /**
@@ -114,24 +114,13 @@ export class ElectronMessagingContribution implements ElectronMainApplicationCon
  * Used to establish a connection between the ipcMain and the Electron frontend (window).
  * Messages a transferred via electron IPC.
  */
-export class ElectronWebContentChannel implements Channel {
-    protected readonly onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
-    get onClose(): Event<ChannelCloseEvent> {
-        return this.onCloseEmitter.event;
-    }
+export class ElectronWebContentChannel extends AbstractChannel {
 
     // Make the message emitter public so that we can easily forward messages received from the ipcMain.
-    readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
-    get onMessage(): Event<MessageProvider> {
-        return this.onMessageEmitter.event;
-    }
-
-    protected readonly onErrorEmitter: Emitter<unknown> = new Emitter();
-    get onError(): Event<unknown> {
-        return this.onErrorEmitter.event;
-    }
+    override readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
 
     constructor(protected readonly sender: Electron.WebContents) {
+        super();
     }
 
     getWriteBuffer(): WriteBuffer {
@@ -145,9 +134,5 @@ export class ElectronWebContentChannel implements Channel {
 
         return writer;
     }
-    close(): void {
-        this.onCloseEmitter.dispose();
-        this.onMessageEmitter.dispose();
-        this.onErrorEmitter.dispose();
-    }
+
 }

package/src/node/i18n/localization-backend-contribution.ts

@@ -16,12 +16,14 @@
 
 import * as express from 'express';
 import { inject, injectable } from 'inversify';
+import { Deferred } from '../../common/promise-util';
 import { BackendApplicationContribution } from '../backend-application';
 import { LocalizationRegistry } from './localization-contribution';
 import { LocalizationProvider } from './localization-provider';
 
 @injectable()
 export class LocalizationBackendContribution implements BackendApplicationContribution {
+    protected readonly initialized = new Deferred<void>();
 
     @inject(LocalizationRegistry)
     protected readonly localizationRegistry: LocalizationRegistry;
@@ -31,15 +33,20 @@ export class LocalizationBackendContribution implements BackendApplicationContri
 
     async initialize(): Promise<void> {
         await this.localizationRegistry.initialize();
+        this.initialized.resolve();
+    }
+
+    waitForInitialization(): Promise<void> {
+        return this.initialized.promise;
     }
 
     configure(app: express.Application): void {
-        app.get('/i18n/:locale', (req, res) => {
+        app.get('/i18n/:locale', async (req, res) => {
+            await this.waitForInitialization();
             let locale = req.params.locale;
             locale = this.localizationProvider.getAvailableLanguages().some(e => e.languageId === locale) ? locale : 'en';
             this.localizationProvider.setCurrentLanguage(locale);
             res.send(this.localizationProvider.loadLocalization(locale));
         });
     }
-
 }

package/src/node/messaging/ipc-channel.ts

@@ -18,7 +18,7 @@
 import * as cp from 'child_process';
 import { Socket } from 'net';
 import { Duplex } from 'stream';
-import { Channel, ChannelCloseEvent, Disposable, DisposableCollection, Emitter, Event, MessageProvider, WriteBuffer } from '../../common';
+import { AbstractChannel, Disposable, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
 import { BinaryMessagePipe } from './binary-message-pipe';
 
@@ -27,29 +27,14 @@ import { BinaryMessagePipe } from './binary-message-pipe';
  * This fd is opened as 5th channel in addition to the default stdios (stdin, stdout, stderr, ipc). This means the default channels
  * are not blocked and can be used by the respective process for additional custom message handling.
  */
-export class IPCChannel implements Channel {
-
-    protected readonly onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
-    get onClose(): Event<ChannelCloseEvent> {
-        return this.onCloseEmitter.event;
-    }
-
-    protected readonly onMessageEmitter: Emitter<MessageProvider> = new Emitter();
-    get onMessage(): Event<MessageProvider> {
-        return this.onMessageEmitter.event;
-    }
-
-    protected readonly onErrorEmitter: Emitter<unknown> = new Emitter();
-    get onError(): Event<unknown> {
-        return this.onErrorEmitter.event;
-    }
+export class IPCChannel extends AbstractChannel {
 
     protected messagePipe: BinaryMessagePipe;
-    protected toDispose = new DisposableCollection();
 
     protected ipcErrorListener: (error: Error) => void = error => this.onErrorEmitter.fire(error);
 
     constructor(childProcess?: cp.ChildProcess) {
+        super();
         if (childProcess) {
             this.setupChildProcess(childProcess);
         } else {
@@ -58,7 +43,6 @@ export class IPCChannel implements Channel {
         this.messagePipe.onMessage(message => {
             this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(message));
         });
-        this.toDispose.pushAll([this.onCloseEmitter, this.onMessageEmitter, this.onErrorEmitter]);
     }
 
     protected setupChildProcess(childProcess: cp.ChildProcess): void {
@@ -90,8 +74,4 @@ export class IPCChannel implements Channel {
         return result;
     }
 
-    close(): void {
-        this.toDispose.dispose();
-    }
-
 }

package/src/node/messaging/ipc-connection-provider.ts

@@ -81,7 +81,11 @@ export class IPCConnectionProvider {
         const forkOptions: cp.ForkOptions = {
             env: createIpcEnv(options),
             execArgv: [],
-            stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'pipe']
+            // 5th element MUST be 'overlapped' for it to work properly on Windows.
+            // 'overlapped' works just like 'pipe' on non-Windows platforms.
+            // See: https://nodejs.org/docs/latest-v14.x/api/child_process.html#child_process_options_stdio
+            // Note: For some reason `@types/node` does not know about 'overlapped'.
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc', 'overlapped' as 'pipe']
         };
         const inspectArgPrefix = `--${options.serverName}-inspect`;
         const inspectArg = process.argv.find(v => v.startsWith(inspectArgPrefix));

package/shared/react-virtualized/index.d.ts

@@ -1 +0,0 @@
-export * from 'react-virtualized';

package/shared/react-virtualized/index.js

@@ -1 +0,0 @@
-module.exports = require('react-virtualized');