@theia/core 1.40.1 → 1.41.0

package/src/common/menu/menu-model-registry.ts

@@ -254,6 +254,56 @@ export class MenuModelRegistry {
         return this.findGroup(menuPath);
     }
 
+    /**
+     * Checks the given menu model whether it will show a menu with a single submenu.
+     *
+     * @param fullMenuModel the menu model to analyze
+     * @param menuPath the menu's path
+     * @returns if the menu will show a single submenu this returns a menu that will show the child elements of the submenu,
+     * otherwise the given `fullMenuModel` is return
+     */
+    removeSingleRootNode(fullMenuModel: MutableCompoundMenuNode, menuPath: MenuPath): CompoundMenuNode {
+        // check whether all children are compound menus and that there is only one child that has further children
+        if (!this.allChildrenCompound(fullMenuModel.children)) {
+            return fullMenuModel;
+        }
+        let nonEmptyNode = undefined;
+        for (const child of fullMenuModel.children) {
+            if (!this.isEmpty(child.children || [])) {
+                if (nonEmptyNode === undefined) {
+                    nonEmptyNode = child;
+                } else {
+                    return fullMenuModel;
+                }
+            }
+        }
+
+        if (CompoundMenuNode.is(nonEmptyNode) && nonEmptyNode.children.length === 1 && CompoundMenuNode.is(nonEmptyNode.children[0])) {
+            nonEmptyNode = nonEmptyNode.children[0];
+        }
+
+        return CompoundMenuNode.is(nonEmptyNode) ? nonEmptyNode : fullMenuModel;
+    }
+
+    protected allChildrenCompound(children: ReadonlyArray<MenuNode>): boolean {
+        return children.every(CompoundMenuNode.is);
+    }
+
+    protected isEmpty(children: ReadonlyArray<MenuNode>): boolean {
+        if (children.length === 0) {
+            return true;
+        }
+        if (!this.allChildrenCompound(children)) {
+            return false;
+        }
+        for (const child of children) {
+            if (!this.isEmpty(child.children || [])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /**
      * Returns the {@link MenuPath path} at which a given menu node can be accessed from this registry, if it can be determined.
      * Returns `undefined` if the `parent` of any node in the chain is unknown.

package/src/common/performance/measurement.ts

@@ -101,4 +101,30 @@ export interface MeasurementOptions {
      * @see {@link thresholdLogLevel}
      */
     thresholdMillis?: number;
+
+    /**
+     * Flag to indicate whether the stopwatch should store measurement results for later retrieval.
+     * For example the cache can be used to retrieve measurements which were taken during startup before a listener had a chance to register.
+     */
+    storeResults?: boolean
+}
+
+/**
+ * Captures the result of a {@link Measurement} in a serializable format.
+ */
+export interface MeasurementResult {
+    /** The measurement name. This may show up in the performance measurement framework appropriate to the application context. */
+    name: string;
+
+    /** The time when the measurement recording has been started */
+    startTime: number;
+
+    /**
+     * The elapsed time measured, if it has been {@link stop stopped} and measured, or `NaN` if the platform disabled
+     * performance measurement.
+     */
+    elapsed: number;
+
+    /** An optional label for the application the start of which (in real time) is the basis of all measurements. */
+    owner?: string;
 }

package/src/common/performance/stopwatch.ts

@@ -19,7 +19,8 @@
 import { inject, injectable } from 'inversify';
 import { ILogger, LogLevel } from '../logger';
 import { MaybePromise } from '../types';
-import { Measurement, MeasurementOptions } from './measurement';
+import { Measurement, MeasurementOptions, MeasurementResult } from './measurement';
+import { Emitter, Event } from '../event';
 
 /** The default log level for measurements that are not otherwise configured with a default. */
 const DEFAULT_LOG_LEVEL = LogLevel.INFO;
@@ -50,10 +51,20 @@ export abstract class Stopwatch {
     @inject(ILogger)
     protected readonly logger: ILogger;
 
+    protected _storedMeasurements: MeasurementResult[] = [];
+
+    protected onDidAddMeasurementResultEmitter = new Emitter<MeasurementResult>();
+    get onDidAddMeasurementResult(): Event<MeasurementResult> {
+        return this.onDidAddMeasurementResultEmitter.event;
+    }
+
     constructor(protected readonly defaultLogOptions: LogOptions) {
         if (!defaultLogOptions.defaultLogLevel) {
             defaultLogOptions.defaultLogLevel = DEFAULT_LOG_LEVEL;
         }
+        if (defaultLogOptions.storeResults === undefined) {
+            defaultLogOptions.storeResults = true;
+        }
     }
 
     /**
@@ -91,25 +102,36 @@ export abstract class Stopwatch {
         return result;
     }
 
-    protected createMeasurement(name: string, measurement: () => number, options?: MeasurementOptions): Measurement {
+    protected createMeasurement(name: string, measure: () => { startTime: number, duration: number }, options?: MeasurementOptions): Measurement {
         const logOptions = this.mergeLogOptions(options);
 
-        const result: Measurement = {
+        const measurement: Measurement = {
             name,
             stop: () => {
-                if (result.elapsed === undefined) {
-                    result.elapsed = measurement();
+                if (measurement.elapsed === undefined) {
+                    const { startTime, duration } = measure();
+                    measurement.elapsed = duration;
+                    const result: MeasurementResult = {
+                        name,
+                        elapsed: duration,
+                        startTime,
+                        owner: logOptions.owner
+                    };
+                    if (logOptions.storeResults) {
+                        this._storedMeasurements.push(result);
+                    }
+                    this.onDidAddMeasurementResultEmitter.fire(result);
                 }
-                return result.elapsed;
+                return measurement.elapsed;
             },
-            log: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, undefined, optionalArgs)),
-            debug: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.DEBUG, optionalArgs)),
-            info: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.INFO, optionalArgs)),
-            warn: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.WARN, optionalArgs)),
-            error: (activity: string, ...optionalArgs: any[]) => this.log(result, activity, this.atLevel(logOptions, LogLevel.ERROR, optionalArgs)),
+            log: (activity: string, ...optionalArgs: any[]) => this.log(measurement, activity, this.atLevel(logOptions, undefined, optionalArgs)),
+            debug: (activity: string, ...optionalArgs: any[]) => this.log(measurement, activity, this.atLevel(logOptions, LogLevel.DEBUG, optionalArgs)),
+            info: (activity: string, ...optionalArgs: any[]) => this.log(measurement, activity, this.atLevel(logOptions, LogLevel.INFO, optionalArgs)),
+            warn: (activity: string, ...optionalArgs: any[]) => this.log(measurement, activity, this.atLevel(logOptions, LogLevel.WARN, optionalArgs)),
+            error: (activity: string, ...optionalArgs: any[]) => this.log(measurement, activity, this.atLevel(logOptions, LogLevel.ERROR, optionalArgs)),
         };
 
-        return result;
+        return measurement;
     }
 
     protected mergeLogOptions(logOptions?: Partial<LogOptions>): LogOptions {
@@ -154,4 +176,8 @@ export abstract class Stopwatch {
         this.logger.log(level, `${whatWasMeasured}: ${elapsed.toFixed(1)} ms [${timeFromStart}]`, ...(options.arguments ?? []));
     }
 
+    get storedMeasurements(): ReadonlyArray<MeasurementResult> {
+        return this._storedMeasurements;
+    }
+
 }

package/src/common/promise-util.spec.ts

@@ -13,22 +13,19 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import * as assert from 'assert';
-import { waitForEvent } from './promise-util';
+import * as assert from 'assert/strict';
+import { firstTrue, waitForEvent } from './promise-util';
 import { Emitter } from './event';
+import { CancellationError } from './cancellation';
 
 describe('promise-util', () => {
-    it('should time out', async () => {
-        const emitter = new Emitter<string>();
-        try {
-            await waitForEvent(emitter.event, 1000);
-            assert.fail('did not time out');
-        } catch (e) {
-            // OK
-        }
-    });
 
-    describe('promise-util', () => {
+    describe('waitForEvent', () => {
+        it('should time out', async () => {
+            const emitter = new Emitter<string>();
+            await assert.rejects(waitForEvent(emitter.event, 1000), reason => reason instanceof CancellationError);
+        });
+
         it('should get event', async () => {
             const emitter = new Emitter<string>();
             setTimeout(() => {
@@ -38,4 +35,38 @@ describe('promise-util', () => {
         });
     });
 
+    describe('firstTrue', () => {
+        it('should resolve to false when the promises arg is empty', async () => {
+            const actual = await firstTrue();
+            assert.strictEqual(actual, false);
+        });
+
+        it('should resolve to true when the first promise resolves to true', async () => {
+            const signals: string[] = [];
+            const createPromise = (signal: string, timeout: number, result: boolean) =>
+                new Promise<boolean>(resolve => setTimeout(() => {
+                    signals.push(signal);
+                    resolve(result);
+                }, timeout));
+            const actual = await firstTrue(
+                createPromise('a', 10, false),
+                createPromise('b', 20, false),
+                createPromise('c', 30, true),
+                createPromise('d', 40, false),
+                createPromise('e', 50, true)
+            );
+            assert.strictEqual(actual, true);
+            assert.deepStrictEqual(signals, ['a', 'b', 'c']);
+        });
+
+        it('should reject when one of the promises rejects', async () => {
+            await assert.rejects(firstTrue(
+                new Promise<boolean>(resolve => setTimeout(() => resolve(false), 10)),
+                new Promise<boolean>(resolve => setTimeout(() => resolve(false), 20)),
+                new Promise<boolean>((_, reject) => setTimeout(() => reject(new Error('my test error')), 30)),
+                new Promise<boolean>(resolve => setTimeout(() => resolve(true), 40)),
+            ), /Error: my test error/);
+        });
+    });
+
 });

package/src/common/promise-util.ts

@@ -129,3 +129,15 @@ export function waitForEvent<T>(event: Event<T>, ms: number, thisArg?: any, disp
 export function isThenable<T>(obj: unknown): obj is Promise<T> {
     return isObject<Promise<unknown>>(obj) && isFunction(obj.then);
 }
+
+/**
+ * Returns with a promise that waits until the first promise resolves to `true`.
+ */
+// Based on https://stackoverflow.com/a/51160727/5529090
+export function firstTrue(...promises: readonly Promise<boolean>[]): Promise<boolean> {
+    const newPromises = promises.map(promise => new Promise<boolean>(
+        (resolve, reject) => promise.then(result => result && resolve(true), reject)
+    ));
+    newPromises.push(Promise.all(promises).then(() => false));
+    return Promise.race(newPromises);
+}

package/src/common/types.ts

@@ -56,6 +56,23 @@ export function isFunction<T extends (...args: unknown[]) => unknown>(value: unk
     return typeof value === 'function';
 }
 
+/**
+ * @returns whether the provided parameter is an empty JavaScript Object or not.
+ */
+export function isEmptyObject(obj: unknown): obj is object {
+    if (!isObject(obj)) {
+        return false;
+    }
+
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 export function isObject<T extends object>(value: unknown): value is UnknownObject<T> {
     // eslint-disable-next-line no-null/no-null
     return typeof value === 'object' && value !== null;

package/src/common/uri.ts

@@ -27,6 +27,10 @@ export class URI {
         return new URI(Uri.file(path));
     }
 
+    public static isUri(uri: unknown): boolean {
+        return Uri.isUri(uri);
+    }
+
     private readonly codeUri: Uri;
     private _path: Path | undefined;
 

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

@@ -100,8 +100,8 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
 
     protected override doRender(options: RenderContextMenuOptions): ContextMenuAccess {
         if (this.useNativeStyle) {
-            const { menuPath, anchor, args, onHide, context, contextKeyService } = options;
-            const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args, context, contextKeyService);
+            const { menuPath, anchor, args, onHide, context, contextKeyService, skipSingleRootNode } = options;
+            const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args, context, contextKeyService, skipSingleRootNode);
             const { x, y } = coordinateFromAnchor(anchor);
 
             const menuHandle = window.electronTheiaCore.popup(menu, x, y, () => {

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

@@ -125,8 +125,8 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         return undefined;
     }
 
-    createElectronContextMenu(menuPath: MenuPath, args?: any[], context?: HTMLElement, contextKeyService?: ContextMatcher): MenuDto[] {
-        const menuModel = this.menuProvider.getMenu(menuPath);
+    createElectronContextMenu(menuPath: MenuPath, args?: any[], context?: HTMLElement, contextKeyService?: ContextMatcher, skipSingleRootNode?: boolean): MenuDto[] {
+        const menuModel = skipSingleRootNode ? this.menuProvider.removeSingleRootNode(this.menuProvider.getMenu(menuPath), menuPath) : this.menuProvider.getMenu(menuPath);
         return this.fillMenuTemplate([], menuModel, args, { showDisabled: true, context, rootMenuPath: menuPath, contextKeyService });
     }
 

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

@@ -507,6 +507,9 @@ export class ElectronMainApplication {
                 backendProcess.on('error', error => {
                     reject(error);
                 });
+                backendProcess.on('exit', () => {
+                    reject(new Error('backend process exited'));
+                });
                 app.on('quit', () => {
                     // Only issue a kill signal if the backend process is running.
                     // eslint-disable-next-line no-null/no-null

package/src/node/backend-application.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import * as dns from 'dns';
 import * as path from 'path';
 import * as http from 'http';
 import * as https from 'https';
@@ -29,6 +30,8 @@ import { AddressInfo } from 'net';
 import { ApplicationPackage } from '@theia/application-package';
 import { ProcessUtils } from './process-utils';
 
+export type DnsResultOrder = 'ipv4first' | 'verbatim' | 'nodeDefault';
+
 const APP_PROJECT_PATH = 'app-project-path';
 
 const TIMER_WARNING_THRESHOLD = 50;
@@ -36,6 +39,7 @@ const TIMER_WARNING_THRESHOLD = 50;
 const DEFAULT_PORT = environment.electron.is() ? 0 : 3000;
 const DEFAULT_HOST = 'localhost';
 const DEFAULT_SSL = false;
+const DEFAULT_DNS_DEFAULT_RESULT_ORDER: DnsResultOrder = 'ipv4first';
 
 export const BackendApplicationServer = Symbol('BackendApplicationServer');
 /**
@@ -107,6 +111,7 @@ export class BackendApplicationCliContribution implements CliContribution {
 
     port: number;
     hostname: string | undefined;
+    dnsDefaultResultOrder: DnsResultOrder = DEFAULT_DNS_DEFAULT_RESULT_ORDER;
     ssl: boolean | undefined;
     cert: string | undefined;
     certkey: string | undefined;
@@ -119,6 +124,12 @@ export class BackendApplicationCliContribution implements CliContribution {
         conf.option('cert', { description: 'Path to SSL certificate.', type: 'string' });
         conf.option('certkey', { description: 'Path to SSL certificate key.', type: 'string' });
         conf.option(APP_PROJECT_PATH, { description: 'Sets the application project directory', default: this.appProjectPath() });
+        conf.option('dnsDefaultResultOrder', {
+            type: 'string',
+            description: 'Configure Node\'s DNS resolver default behavior, see https://nodejs.org/docs/latest-v18.x/api/dns.html#dnssetdefaultresultorderorder',
+            choices: ['ipv4first', 'verbatim', 'nodeDefault'],
+            default: DEFAULT_DNS_DEFAULT_RESULT_ORDER
+        });
     }
 
     setArguments(args: yargs.Arguments): void {
@@ -128,6 +139,7 @@ export class BackendApplicationCliContribution implements CliContribution {
         this.cert = args.cert as string;
         this.certkey = args.certkey as string;
         this.projectPath = args[APP_PROJECT_PATH] as string;
+        this.dnsDefaultResultOrder = args.dnsDefaultResultOrder as DnsResultOrder;
     }
 
     protected appProjectPath(): string {
@@ -234,9 +246,13 @@ export class BackendApplication {
         this.app.use(...handlers);
     }
 
-    async start(aPort?: number, aHostname?: string): Promise<http.Server | https.Server> {
-        const hostname = aHostname !== undefined ? aHostname : this.cliParams.hostname;
-        const port = aPort !== undefined ? aPort : this.cliParams.port;
+    async start(port?: number, hostname?: string): Promise<http.Server | https.Server> {
+        hostname ??= this.cliParams.hostname;
+        port ??= this.cliParams.port;
+
+        if (this.cliParams.dnsDefaultResultOrder !== 'nodeDefault') {
+            dns.setDefaultResultOrder(this.cliParams.dnsDefaultResultOrder);
+        }
 
         const deferred = new Deferred<http.Server | https.Server>();
         let server: http.Server | https.Server;
@@ -279,8 +295,10 @@ export class BackendApplication {
         });
 
         server.listen(port, hostname, () => {
-            const scheme = this.cliParams.ssl ? 'https' : 'http';
-            console.info(`Theia app listening on ${scheme}://${hostname || 'localhost'}:${(server.address() as AddressInfo).port}.`);
+            // address should be defined at this point
+            const address = server.address()!;
+            const url = typeof address === 'string' ? address : this.getHttpUrl(address, this.cliParams.ssl);
+            console.info(`Theia app listening on ${url}.`);
             deferred.resolve(server);
         });
 
@@ -301,6 +319,13 @@ export class BackendApplication {
         return this.stopwatch.startAsync('server', 'Finished starting backend application', () => deferred.promise);
     }
 
+    protected getHttpUrl({ address, port, family }: AddressInfo, ssl?: boolean): string {
+        const scheme = ssl ? 'https' : 'http';
+        return family.toLowerCase() === 'ipv6'
+            ? `${scheme}://[${address}]:${port}`
+            : `${scheme}://${address}:${port}`;
+    }
+
     protected onStop(): void {
         console.info('>>> Stopping backend contributions...');
         for (const contrib of this.contributionsProvider.getContributions()) {

package/src/node/logger-cli-contribution.spec.ts

@@ -137,7 +137,7 @@ describe('log-level-cli-contribution', () => {
 
         const args: yargs.Arguments = yargs.parse(['--log-config', file.path]);
         await cli.setArguments(args);
-        sinon.assert.calledWithMatch(consoleErrorSpy, 'Unexpected token { in JSON at position 1');
+        sinon.assert.calledWithMatch(consoleErrorSpy, 'Error reading log config file');
     });
 
     // Skip this test because it is flaky, sometimes we don't receive the event.

package/src/node/main.ts

@@ -26,12 +26,7 @@ process.on('unhandledRejection', (reason, promise) => {
     throw reason;
 });
 
-export interface Address {
-    readonly port: number;
-    readonly address: string;
-}
-
-export async function start(serverModule: MaybePromise<http.Server | https.Server>): Promise<Address> {
+export async function start(serverModule: MaybePromise<http.Server | https.Server>): Promise<AddressInfo> {
     const server = await serverModule;
     return server.address() as AddressInfo;
 }

package/src/node/performance/node-stopwatch.ts

@@ -33,7 +33,7 @@ export class NodeStopwatch extends Stopwatch {
 
         return this.createMeasurement(name, () => {
             const duration = performance.now() - startTime;
-            return duration;
+            return { duration, startTime };
         }, options);
     }