@theia/core 1.45.1 → 1.46.0-next.106

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

@@ -16,7 +16,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { CancellationToken, CancellationTokenSource } from '../cancellation';
-import { Disposable, DisposableCollection } from '../disposable';
+import { DisposableWrapper, Disposable, DisposableCollection } from '../disposable';
 import { Emitter, Event } from '../event';
 import { Deferred } from '../promise-util';
 import { Channel } from './channel';
@@ -57,6 +57,7 @@ export class RpcProtocol {
     static readonly CANCELLATION_TOKEN_KEY = 'add.cancellation.token';
 
     protected readonly pendingRequests: Map<number, Deferred<any>> = new Map();
+    protected readonly pendingRequestCancellationEventListeners: Map<number, DisposableWrapper> = new Map();
 
     protected nextMessageId: number = 0;
 
@@ -80,6 +81,8 @@ export class RpcProtocol {
         channel.onClose(event => {
             this.pendingRequests.forEach(pending => pending.reject(new Error(event.reason)));
             this.pendingRequests.clear();
+            this.pendingRequestCancellationEventListeners.forEach(disposable => disposable.dispose());
+            this.pendingRequestCancellationEventListeners.clear();
             this.toDispose.dispose();
         });
         this.toDispose.push(channel.onMessage(readBuffer => this.handleMessage(this.decoder.parse(readBuffer()))));
@@ -131,6 +134,7 @@ export class RpcProtocol {
         } else {
             throw new Error(`No reply handler for reply with id: ${id}`);
         }
+        this.disposeCancellationEventListener(id);
     }
 
     protected handleReplyErr(id: number, error: any): void {
@@ -141,6 +145,15 @@ export class RpcProtocol {
         } else {
             throw new Error(`No reply handler for error reply with id: ${id}`);
         }
+        this.disposeCancellationEventListener(id);
+    }
+
+    protected disposeCancellationEventListener(id: number): void {
+        const toDispose = this.pendingRequestCancellationEventListeners.get(id);
+        if (toDispose) {
+            this.pendingRequestCancellationEventListeners.delete(id);
+            toDispose.dispose();
+        }
     }
 
     sendRequest<T>(method: string, args: any[]): Promise<T> {
@@ -157,6 +170,10 @@ export class RpcProtocol {
 
         this.pendingRequests.set(id, reply);
 
+        // register disposable before output.commit() even when not available yet
+        const disposableWrapper = new DisposableWrapper();
+        this.pendingRequestCancellationEventListeners.set(id, disposableWrapper);
+
         const output = this.channel.getWriteBuffer();
         this.encoder.request(output, id, method, args);
         output.commit();
@@ -164,7 +181,10 @@ export class RpcProtocol {
         if (cancellationToken?.isCancellationRequested) {
             this.sendCancel(id);
         } else {
-            cancellationToken?.onCancellationRequested(() => this.sendCancel(id));
+            const disposable = cancellationToken?.onCancellationRequested(() => this.sendCancel(id));
+            if (disposable) {
+                disposableWrapper.set(disposable);
+            }
         }
 
         return reply.promise;

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

@@ -168,14 +168,7 @@ export class RpcProxyFactory<T extends object> implements ProxyHandler<T> {
                 throw new Error(`no target was set to handle ${method}`);
             }
         } catch (error) {
-            const e = this.serializeError(error);
-            if (e instanceof ResponseError) {
-                throw e;
-            }
-            const reason = e.message || '';
-            const stack = e.stack || '';
-            console.error(`Request ${method} failed with error: ${reason}`, stack);
-            throw e;
+            throw this.serializeError(error);
         }
     }
 

package/src/common/nls.ts

@@ -83,7 +83,9 @@ class LocalizationKeyProvider {
 
     private preferredKeys = new Set([
         // We only want the `File` translation used in the menu
-        'vscode/fileActions.contribution/filesCategory'
+        'vscode/fileActions.contribution/filesCategory',
+        // Needed for `Close Editor` translation
+        'vscode/editor.contribution/closeEditor'
     ]);
     private data = this.buildData();
 

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

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import * as assert from 'assert/strict';
-import { firstTrue, waitForEvent } from './promise-util';
+import { Deferred, firstTrue, waitForEvent } from './promise-util';
 import { Emitter } from './event';
 import { CancellationError } from './cancellation';
 
@@ -35,7 +35,30 @@ describe('promise-util', () => {
         });
     });
 
+    type ExecutionHandler<T> = (resolve: (value: T) => void, reject: (error: unknown) => void) => void;
+
     describe('firstTrue', () => {
+        function createSequentialPromises<T>(...executionHandlers: ExecutionHandler<T>[]): Promise<T>[] {
+            const deferreds: Deferred<T>[] = [];
+            let i = 0;
+            for (let k = 0; k < executionHandlers.length; k++) {
+                deferreds.push(new Deferred<T>());
+            }
+
+            const resolveNext = () => {
+                if (i < executionHandlers.length) {
+                    executionHandlers[i](value => deferreds[i].resolve(value), error => deferreds[i].reject(error));
+                    i++;
+                }
+                if (i < executionHandlers.length) {
+                    setTimeout(resolveNext, 1);
+                }
+            };
+
+            setTimeout(resolveNext, 1);
+            return deferreds.map(deferred => deferred.promise);
+        }
+
         it('should resolve to false when the promises arg is empty', async () => {
             const actual = await firstTrue();
             assert.strictEqual(actual, false);
@@ -43,29 +66,36 @@ describe('promise-util', () => {
 
         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(() => {
+
+            function createHandler(signal: string, result?: boolean): ExecutionHandler<boolean> {
+                return (resolve: (value: boolean) => void, reject: (error: unknown) => void) => {
                     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)
-            );
+                    if (typeof result !== 'undefined') {
+                        resolve(result);
+                    } else {
+                        reject(undefined);
+                    }
+                };
+            }
+
+            const actual = await firstTrue(...createSequentialPromises(
+                createHandler('a', false),
+                createHandler('b', false),
+                createHandler('c', true),
+                createHandler('d', false),
+                createHandler('e', 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/);
+            await assert.rejects(firstTrue(...createSequentialPromises<boolean>(
+                (resolve, _) => resolve(false),
+                resolve => resolve(false),
+                (_, reject) => reject(new Error('my test error')),
+                resolve => resolve(true),
+            )), /Error: my test error/);
         });
     });
 

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

@@ -14,7 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import URI from './uri';
 import * as fuzzy from 'fuzzy';
 import { Event } from './event';
 import { KeySequence } from './keys';
@@ -54,11 +53,11 @@ export interface QuickPickItem {
     description?: string;
     detail?: string;
     keySequence?: KeySequence;
-    iconPath?: URI | Uri | { light?: URI | Uri; dark: URI | Uri } | { id: string };
+    iconPath?: { light?: Uri; dark: Uri };
     iconClasses?: string[];
     alwaysShow?: boolean;
     highlights?: QuickPickItemHighlights;
-    buttons?: readonly QuickInputButton[];
+    buttons?: QuickInputButton[];
     execute?: () => void;
 }
 
@@ -95,7 +94,7 @@ export interface QuickPickValue<V> extends QuickPickItem {
 }
 
 export interface QuickInputButton {
-    iconPath?: URI | Uri | { light?: URI | Uri; dark: URI | Uri } | { id: string };
+    iconPath?: { light?: Uri; dark: Uri };
     iconClass?: string;
     tooltip?: string;
     /**
@@ -104,34 +103,8 @@ export interface QuickInputButton {
     alwaysVisible?: boolean;
 }
 
-export interface NormalizedQuickInputButton extends QuickInputButton {
-    iconPath?: { light?: Uri, dark: Uri };
-}
-
-export namespace QuickInputButton {
-    export function normalize(button: undefined): undefined;
-    export function normalize(button: QuickInputButton): NormalizedQuickInputButton;
-    export function normalize(button?: QuickInputButton): NormalizedQuickInputButton | undefined {
-        if (!button) {
-            return button;
-        }
-        let iconPath: NormalizedQuickInputButton['iconPath'] = undefined;
-        if (button.iconPath instanceof URI) {
-            iconPath = { dark: button.iconPath['codeUri'] };
-        } else if (button.iconPath && 'dark' in button.iconPath) {
-            const dark = Uri.isUri(button.iconPath.dark) ? button.iconPath.dark : button.iconPath.dark['codeUri'];
-            const light = Uri.isUri(button.iconPath.light) ? button.iconPath.light : button.iconPath.light?.['codeUri'];
-            iconPath = { dark, light };
-        }
-        return {
-            ...button,
-            iconPath,
-        };
-    }
-}
-
 export interface QuickInputButtonHandle extends QuickInputButton {
-    index: number; // index of where they are in buttons array if QuickInputButton or -1 if QuickInputButtons.Back
+    handle: number; // index of where the button is in buttons array if QuickInputButton or -1 if QuickInputButtons.Back
 }
 
 export enum QuickInputHideReason {
@@ -188,10 +161,11 @@ export interface QuickPick<T extends QuickPickItemOrSeparator> extends QuickInpu
     matchOnDescription: boolean;
     matchOnDetail: boolean;
     keepScrollPosition: boolean;
+    buttons: ReadonlyArray<QuickInputButton>;
     readonly onDidAccept: Event<{ inBackground: boolean } | undefined>;
     readonly onDidChangeValue: Event<string>;
     readonly onDidTriggerButton: Event<QuickInputButton>;
-    readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<T>>;
+    readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<QuickPickItem>>;
     readonly onDidChangeActive: Event<T[]>;
     readonly onDidChangeSelection: Event<T[]>;
 }
@@ -281,8 +255,13 @@ export interface QuickInputService {
     open(filter: string): void;
     createInputBox(): InputBox;
     input(options?: InputOptions, token?: CancellationToken): Promise<string | undefined>;
-    pick<T extends QuickPickItem, O extends PickOptions<T>>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: O, token?: CancellationToken):
-        Promise<(O extends { canPickMany: true } ? T[] : T) | undefined>;
+    pick<T extends QuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[],
+        options?: PickOptions<T> & { canPickMany: true }, token?: CancellationToken): Promise<T[] | undefined>;
+    pick<T extends QuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[],
+        options?: PickOptions<T> & { canPickMany: false }, token?: CancellationToken): Promise<T | undefined>;
+    pick<T extends QuickPickItem>(picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[],
+        options?: Omit<PickOptions<T>, 'canPickMany'>, token?: CancellationToken): Promise<T | undefined>;
+
     showQuickPick<T extends QuickPickItem>(items: Array<T | QuickPickSeparator>, options?: QuickPickOptions<T>): Promise<T | undefined>;
     hide(): void;
     /**

package/src/common/reference.ts

@@ -22,6 +22,50 @@ export interface Reference<T> extends Disposable {
     readonly object: T
 }
 
+/**
+ * Abstract class for a map of reference-counted disposable objects, with the
+ * following features:
+ *
+ *    - values are not inserted explicitly; instead, acquire() is used to
+ *      create the value for a given key, or return the previously created
+ *      value for it. How the value is created for a given key is
+ *      implementation specific.
+ *
+ *    - any subsquent acquire() with the same key will bump the reference
+ *      count on that value. acquire() returns not the value directly but
+ *      a reference object that holds the value. Calling dispose() on the
+ *      reference decreases the value's effective reference count.
+ *
+ *    - a contained value will have its dispose() function called when its
+ *      reference count reaches zero. The key/value pair will be purged
+ *      from the collection.
+ *
+ *    - calling dispose() on the value directly, instead of calling it on
+ *      the reference returned by acquire(), will automatically dispose
+ *      all outstanding references to that value and the key/value pair
+ *      will be purged from the collection.
+ *
+ *    - supports synchronous and asynchronous implementations. acquire() will
+ *      return a Promise if the value cannot be created immediately
+ *
+ *    - functions has|keys|values|get are always synchronous and the result
+ *      excludes asynchronous additions in flight.
+ *
+ *    - functions values|get return the value directly and not a reference
+ *      to the value. Use these functions to obtain a value without bumping
+ *      its reference count.
+ *
+ *    - clients can register to be notified when values are added and removed;
+ *      notification for asynchronous additions happen when the creation
+ *      completes, not when it's requested.
+ *
+ *    - keys can be any value/object that can be successfully stringified using
+ *      JSON.stringify(), sans arguments
+ *
+ *    - calling dispose() on the collection will dispose all outstanding
+ *      references to all contained values, which results in the disposal of
+ *      the values themselves.
+ */
 export abstract class AbstractReferenceCollection<K, V extends Disposable> implements Disposable {
 
     protected readonly _keys = new Map<string, K>();
@@ -108,6 +152,12 @@ export abstract class AbstractReferenceCollection<K, V extends Disposable> imple
 
 }
 
+/**
+ * Asynchronous implementation of AbstractReferenceCollection that requires
+ * the client to provide a value factory, used to service the acquire()
+ * function. That factory may return a Promise if the value cannot be
+ * created immediately.
+ */
 export class ReferenceCollection<K, V extends Disposable> extends AbstractReferenceCollection<K, V> {
 
     constructor(protected readonly factory: (key: K) => MaybePromise<V>) {
@@ -148,6 +198,11 @@ export class ReferenceCollection<K, V extends Disposable> extends AbstractRefere
 
 }
 
+/**
+ * Synchronous implementation of AbstractReferenceCollection that requires
+ * the client to provide a value factory, used to service the acquire()
+ * function.
+ */
 export class SyncReferenceCollection<K, V extends Disposable> extends AbstractReferenceCollection<K, V> {
 
     constructor(protected readonly factory: (key: K) => V) {

package/src/common/resource.ts

@@ -25,6 +25,7 @@ import { CancellationToken } from './cancellation';
 import { ApplicationError } from './application-error';
 import { ReadableStream, Readable } from './stream';
 import { SyncReferenceCollection, Reference } from './reference';
+import { MarkdownString } from './markdown-rendering';
 
 export interface ResourceVersion {
 }
@@ -55,7 +56,10 @@ export interface Resource extends Disposable {
      * Undefined if a resource did not read content yet.
      */
     readonly encoding?: string | undefined;
-    readonly isReadonly?: boolean;
+
+    readonly onDidChangeReadOnly?: Event<boolean | MarkdownString>;
+
+    readonly readOnly?: boolean | MarkdownString;
     /**
      * Reads latest content of this resource.
      *

package/src/common/theme.ts

@@ -14,6 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { URI } from 'vscode-uri';
+
 export type ThemeType = 'light' | 'dark' | 'hc' | 'hcLight';
 
 export interface Theme {
@@ -34,3 +36,33 @@ export interface ThemeChangeEvent {
     readonly newTheme: Theme;
     readonly oldTheme?: Theme;
 }
+
+export interface ThemeColor {
+    id: string;
+}
+
+export interface ThemeIcon {
+    readonly id: string;
+    readonly color?: ThemeColor;
+}
+
+export interface IconDefinition {
+    font?: IconFontContribution; // undefined for the default font (codicon)
+    fontCharacter: string;
+}
+
+export interface IconFontContribution {
+    readonly id: string;
+    readonly definition: IconFontDefinition;
+}
+
+export interface IconFontDefinition {
+    readonly weight?: string;
+    readonly style?: string;
+    readonly src: IconFontSource[];
+}
+
+export interface IconFontSource {
+    readonly location: URI;
+    readonly format: string;
+}

package/src/common/uri.ts

@@ -19,8 +19,10 @@ import { Path } from './path';
 
 export class URI {
 
-    public static fromComponents(components: UriComponents): URI {
-        return new URI(Uri.revive(components));
+    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;
     }
 
     public static fromFilePath(path: string): URI {

package/src/common/uuid.ts

@@ -21,79 +21,25 @@
 
 // based on https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/uuid.ts
 
+import { v4, v5 } from 'uuid';
+
 const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 export function isUUID(value: string): boolean {
     return _UUIDPattern.test(value);
 }
 
-declare const crypto: undefined | {
-    // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#browser_compatibility
-    getRandomValues?(data: Uint8Array): Uint8Array;
-    // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID#browser_compatibility
-    randomUUID?(): string;
-};
-
-export const generateUuid = (function (): () => string {
-
-    // use `randomUUID` if possible
-    if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
-        return crypto.randomUUID.bind(crypto);
-    }
-
-    // use `randomValues` if possible
-    let getRandomValues: (bucket: Uint8Array) => Uint8Array;
-    if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
-        getRandomValues = crypto.getRandomValues.bind(crypto);
-
-    } else {
-        getRandomValues = function (bucket: Uint8Array): Uint8Array {
-            for (let i = 0; i < bucket.length; i++) {
-                bucket[i] = Math.floor(Math.random() * 256);
-            }
-            return bucket;
-        };
-    }
-
-    // prep-work
-    const _data = new Uint8Array(16);
-    const _hex: string[] = [];
-    for (let i = 0; i < 256; i++) {
-        _hex.push(i.toString(16).padStart(2, '0'));
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    return function generateUuid(): string {
-        // get data
-        getRandomValues(_data);
-
-        // set version bits
-        _data[6] = (_data[6] & 0x0f) | 0x40;
-        _data[8] = (_data[8] & 0x3f) | 0x80;
+export function generateUuid(): string {
+    return v4();
+}
 
-        // print as string
-        let i = 0;
-        let result = '';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        return result;
-    };
-})();
+const NAMESPACE = '4c90ee4f-d952-44b1-83ca-f04121ab8e05';
+/**
+ * This function will hash the given value using SHA1. The result will be a uuid.
+ * @param value the string to hash
+ * @returns a uuid
+ */
+export function hashValue(value: string): string {
+    // as opposed to v4, v5 is deterministic and uses SHA1 hashing
+    return v5(value, NAMESPACE);
+}

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

@@ -18,7 +18,7 @@ import { inject, injectable, postConstruct } from 'inversify';
 import { Command, CommandContribution, CommandRegistry, isOSX, isWindows, MenuModelRegistry, MenuContribution, Disposable, nls } from '../../common';
 import {
     codicon, ConfirmDialog, KeybindingContribution, KeybindingRegistry, PreferenceScope, Widget,
-    FrontendApplication, FrontendApplicationContribution, CommonMenus, CommonCommands, Dialog, Message, ApplicationShell,
+    FrontendApplication, FrontendApplicationContribution, CommonMenus, CommonCommands, Dialog, Message, ApplicationShell, PreferenceService, animationFrame,
 } from '../../browser';
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { FrontendApplicationStateService, FrontendApplicationState } from '../../browser/frontend-application-state';
@@ -441,6 +441,9 @@ export class CustomTitleWidget extends Widget {
     @inject(ApplicationShell)
     protected readonly applicationShell: ApplicationShell;
 
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
     constructor() {
         super();
         this.id = 'theia-custom-title';
@@ -452,6 +455,11 @@ export class CustomTitleWidget extends Widget {
         this.windowTitleService.onDidChangeTitle(title => {
             this.updateTitle(title);
         });
+        this.preferenceService.onPreferenceChanged(e => {
+            if (e.preferenceName === 'window.menuBarVisibility') {
+                animationFrame().then(() => this.adjustTitleToCenter());
+            }
+        });
     }
 
     protected override onResize(msg: Widget.ResizeMessage): void {

package/src/electron-browser/messaging/electron-messaging-frontend-module.ts

@@ -23,7 +23,7 @@ import { ElectronFrontendIdProvider } from './electron-frontend-id-provider';
 import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
 import { ConnectionSource } from '../../browser/messaging/connection-source';
 import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
-import { WebSocketConnectionProvider } from '../../browser';
+import { WebSocketConnectionProvider } from '../../browser/messaging/ws-connection-provider';
 import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
 import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
 

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

@@ -21,6 +21,7 @@ import { ElectronMainWindowService } from '../../electron-common/electron-main-w
 import { ElectronWindowPreferences } from './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';
 
 @injectable()
 export class ElectronWindowService extends DefaultWindowService {
@@ -86,12 +87,20 @@ export class ElectronWindowService extends DefaultWindowService {
         }
     }
 
-    override reload(params?: WindowSearchParams): void {
+    override reload(params?: WindowReloadOptions): void {
         if (params) {
-            const query = Object.entries(params).map(([name, value]) => `${name}=${value}`).join('&');
-            location.search = query;
+            const newLocation = new URL(location.href);
+            if (params.search) {
+                const query = Object.entries(params.search).map(([name, value]) => `${name}=${value}`).join('&');
+                newLocation.search = query;
+            }
+            if (params.hash) {
+                newLocation.hash = '#' + params.hash;
+            }
+            location.assign(newLocation);
         } else {
             window.electronTheiaCore.requestReload();
         }
     }
 }
+

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

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { v4 } from 'uuid';
+import { generateUuid } from '../common/uuid';
 import { bindContributionProvider } from '../common/contribution-provider';
 import { RpcConnectionHandler } from '../common/messaging/proxy-factory';
 import { ElectronSecurityToken } from '../electron-common/electron-token';
@@ -29,7 +29,7 @@ import { ElectronSecurityTokenService } from './electron-security-token-service'
 import { ElectronMessagingService } from './messaging/electron-messaging-service';
 import { ElectronConnectionHandler } from './messaging/electron-connection-handler';
 
-const electronSecurityToken: ElectronSecurityToken = { value: v4() };
+const electronSecurityToken: ElectronSecurityToken = { value: generateUuid() };
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 (global as any)[ElectronSecurityToken] = electronSecurityToken;
 

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

@@ -24,7 +24,7 @@ import { existsSync, mkdirSync } from 'fs-extra';
 import { fork, ForkOptions } from 'child_process';
 import { DefaultTheme, FrontendApplicationConfig } from '@theia/application-package/lib/application-props';
 import URI from '../common/uri';
-import { FileUri } from '../node/file-uri';
+import { FileUri } from '../common/file-uri';
 import { Deferred } from '../common/promise-util';
 import { MaybePromise } from '../common/types';
 import { ContributionProvider } from '../common/contribution-provider';

package/src/electron-main/theia-electron-window.ts

@@ -22,7 +22,7 @@ import { ElectronMainApplicationGlobals } from './electron-main-constants';
 import { DisposableCollection, Emitter, Event } from '../common';
 import { createDisposableListener } from './event-utils';
 import { URI } from '../common/uri';
-import { FileUri } from '../node/file-uri';
+import { FileUri } from '../common/file-uri';
 import { TheiaRendererAPI } from './electron-api-main';
 
 /**