@theia/core 1.47.0-next.0 → 1.47.1

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,32 +103,6 @@ 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 {
     handle: number; // index of where the button is in buttons array if QuickInputButton or -1 if QuickInputButtons.Back
 }
@@ -281,8 +254,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/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,7 +21,7 @@
 
 // based on https://github.com/microsoft/vscode/blob/1.72.2/src/vs/base/common/uuid.ts
 
-import { v5 } from 'uuid';
+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;
 
@@ -29,76 +29,9 @@ 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;
-
-        // 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;
-    };
-})();
+export function generateUuid(): string {
+    return v4();
+}
 
 const NAMESPACE = '4c90ee4f-d952-44b1-83ca-f04121ab8e05';
 /**

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-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;