@theia/core 1.45.1 → 1.46.0-next.137

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

@@ -14,13 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, named } from 'inversify';
-import { Disposable } from '../disposable';
-import { CommandRegistry, Command } from '../command';
+import { inject, injectable, named } from 'inversify';
+import { Command, CommandRegistry } from '../command';
 import { ContributionProvider } from '../contribution-provider';
-import { CompositeMenuNode, CompositeMenuNodeWrapper } from './composite-menu-node';
-import { CompoundMenuNode, MenuAction, MenuNode, MenuPath, MutableCompoundMenuNode, SubMenuOptions } from './menu-types';
+import { Disposable } from '../disposable';
 import { ActionMenuNode } from './action-menu-node';
+import { CompositeMenuNode, CompositeMenuNodeWrapper } from './composite-menu-node';
+import { CompoundMenuNode, MenuAction, MenuNode, MenuNodeMetadata, MenuPath, MutableCompoundMenuNode, SubMenuOptions } from './menu-types';
 
 export const MenuContribution = Symbol('MenuContribution');
 
@@ -157,6 +157,23 @@ export class MenuModelRegistry {
     linkSubmenu(parentPath: MenuPath | string, childId: string | MenuPath, options?: SubMenuOptions, group?: string): Disposable {
         const child = this.getMenuNode(childId);
         const parent = this.getMenuNode(parentPath, group);
+
+        const isRecursive = (node: MenuNodeMetadata, childNode: MenuNodeMetadata): boolean => {
+            if (node.id === childNode.id) {
+                return true;
+            }
+            if (node.parent) {
+                return isRecursive(node.parent, childNode);
+            }
+            return false;
+        };
+
+        // check for menu contribution recursion
+        if (isRecursive(parent, child)) {
+            console.warn(`Recursive menu contribution detected: ${child.id} is already in hierarchy of ${parent.id}.`);
+            return Disposable.NULL;
+        }
+
         const wrapper = new CompositeMenuNodeWrapper(child, parent, options);
         return parent.addNode(wrapper);
     }

package/src/common/menu/menu.spec.ts

@@ -14,10 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { CommandContribution, CommandRegistry } from '../command';
-import { MenuContribution, MenuModelRegistry } from './menu-model-registry';
 import * as chai from 'chai';
+import { CommandContribution, CommandRegistry } from '../command';
 import { CompositeMenuNode } from './composite-menu-node';
+import { MenuContribution, MenuModelRegistry } from './menu-model-registry';
 
 const expect = chai.expect;
 
@@ -61,6 +61,25 @@ describe('menu-model-registry', () => {
             expect(openGroup.children.length).equals(2);
             expect(openGroup.label).undefined;
         });
+
+        it('Should not allow to register cyclic menus.', () => {
+            const fileMenu = ['main', 'File'];
+            const fileOpenMenu = [...fileMenu, '0_open'];
+            const fileCloseMenu = [...fileMenu, '1_close'];
+            const service = createMenuRegistry({
+                registerMenus(menuRegistry: MenuModelRegistry): void {
+                    menuRegistry.registerSubmenu(fileMenu, 'File');
+                    // open menu should not be added to open menu
+                    menuRegistry.linkSubmenu(fileOpenMenu, fileOpenMenu);
+                    // close menu should be added
+                    menuRegistry.linkSubmenu(fileOpenMenu, fileCloseMenu);
+                }
+            }, {
+                registerCommands(reg: CommandRegistry): void { }
+            });
+            const all = service.getMenu() as CompositeMenuNode;
+            expect(menuStructureToString(all.children[0] as CompositeMenuNode)).equals('File(0_open(1_close),1_close())');
+        });
     });
 });
 
@@ -71,3 +90,12 @@ function createMenuRegistry(menuContrib: MenuContribution, commandContrib: Comma
     menuReg.onStart();
     return menuReg;
 }
+
+function menuStructureToString(node: CompositeMenuNode): string {
+    return node.children.map(c => {
+        if (c instanceof CompositeMenuNode) {
+            return `${c.id}(${menuStructureToString(c)})`;
+        }
+        return c.id;
+    }).join(',');
+}

package/src/common/message-rpc/msg-pack-extension-manager.ts

@@ -21,7 +21,7 @@ import { addExtension } from 'msgpackr';
  * required for the default RPC communication. MsgPackR extensions
  * are installed globally on both ends of the communication channel.
  * (frontend-backend, pluginExt-pluginMain).
- * Is implemented as singleton as it is  also used in plugin child processes which have no access to inversify.
+ * Is implemented as singleton as it is also used in plugin child processes which have no access to inversify.
  */
 export class MsgPackExtensionManager {
     private static readonly INSTANCE = new MsgPackExtensionManager();

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-context-menu-renderer.ts

@@ -104,11 +104,13 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
             const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args, context, contextKeyService, skipSingleRootNode);
             const { x, y } = coordinateFromAnchor(anchor);
 
+            const windowName = options.context?.ownerDocument.defaultView?.Window.name;
+
             const menuHandle = window.electronTheiaCore.popup(menu, x, y, () => {
                 if (onHide) {
                     onHide();
                 }
-            });
+            }, windowName);
             // native context menu stops the event loop, so there is no keyboard events
             this.context.resetAltPressed();
             return new ElectronContextMenuAccess(menuHandle);