@theia/core 1.51.0 → 1.53.0-next.4

package/src/browser/undo-redo-handler.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, named, postConstruct } from 'inversify';
+import { ContributionProvider } from '../common';
+
+export const UndoRedoHandler = Symbol('UndoRedoHandler');
+
+export interface UndoRedoHandler<T> {
+    priority: number;
+    select(): T | undefined;
+    undo(item: T): void;
+    redo(item: T): void;
+}
+
+@injectable()
+export class UndoRedoHandlerService {
+
+    @inject(ContributionProvider) @named(UndoRedoHandler)
+    protected readonly provider: ContributionProvider<UndoRedoHandler<unknown>>;
+
+    protected handlers: UndoRedoHandler<unknown>[];
+
+    @postConstruct()
+    protected init(): void {
+        this.handlers = this.provider.getContributions().sort((a, b) => b.priority - a.priority);
+    }
+
+    undo(): void {
+        for (const handler of this.handlers) {
+            const selection = handler.select();
+            if (selection) {
+                handler.undo(selection);
+                return;
+            }
+        }
+    }
+
+    redo(): void {
+        for (const handler of this.handlers) {
+            const selection = handler.select();
+            if (selection) {
+                handler.redo(selection);
+                return;
+            }
+        }
+    }
+
+}
+
+@injectable()
+export class DomInputUndoRedoHandler implements UndoRedoHandler<Element> {
+
+    priority = 1000;
+
+    select(): Element | undefined {
+        const element = document.activeElement;
+        if (element && ['input', 'textarea'].includes(element.tagName.toLowerCase())) {
+            return element;
+        }
+        return undefined;
+    }
+
+    undo(item: Element): void {
+        document.execCommand('undo');
+    }
+
+    redo(item: Element): void {
+        document.execCommand('redo');
+    }
+
+}

package/src/browser/widget-manager.ts

@@ -114,7 +114,7 @@ export class WidgetManager {
 
     protected _cachedFactories: Map<string, WidgetFactory>;
     protected readonly widgets = new Map<string, Widget>();
-    protected readonly pendingWidgetPromises = new Map<string, MaybePromise<Widget>>();
+    protected readonly pendingWidgetPromises = new Map<string, Promise<Widget>>();
 
     @inject(ContributionProvider) @named(WidgetFactory)
     protected readonly factoryProvider: ContributionProvider<WidgetFactory>;
@@ -207,9 +207,9 @@ export class WidgetManager {
                 return widget as T;
             }
         }
-        for (const [key, widget] of this.pendingWidgetPromises.entries()) {
+        for (const [key, widgetPromise] of this.pendingWidgetPromises.entries()) {
             if (this.testPredicate(key, factoryId, predicate)) {
-                return widget as T;
+                return widgetPromise as Promise<T>;
             }
         }
     }
@@ -244,18 +244,26 @@ export class WidgetManager {
         if (!factory) {
             throw Error("No widget factory '" + factoryId + "' has been registered.");
         }
-        try {
-            const widgetPromise = factory.createWidget(options);
-            this.pendingWidgetPromises.set(key, widgetPromise);
-            const widget = await widgetPromise;
-            await WaitUntilEvent.fire(this.onWillCreateWidgetEmitter, { factoryId, widget });
+        const widgetPromise = this.doCreateWidget<T>(factory, options).then(widget => {
             this.widgets.set(key, widget);
             widget.disposed.connect(() => this.widgets.delete(key));
             this.onDidCreateWidgetEmitter.fire({ factoryId, widget });
-            return widget as T;
-        } finally {
-            this.pendingWidgetPromises.delete(key);
+            return widget;
+        }).finally(() => this.pendingWidgetPromises.delete(key));
+        this.pendingWidgetPromises.set(key, widgetPromise);
+        return widgetPromise;
+    }
+
+    protected async doCreateWidget<T extends Widget>(factory: WidgetFactory, options?: any): Promise<T> {
+        const widget = await factory.createWidget(options);
+        // Note: the widget creation process also includes the 'onWillCreateWidget' part, which can potentially fail
+        try {
+            await WaitUntilEvent.fire(this.onWillCreateWidgetEmitter, { factoryId: factory.id, widget });
+        } catch (e) {
+            widget.dispose();
+            throw e;
         }
+        return widget as T;
     }
 
     /**

package/src/browser/widget-open-handler.ts

@@ -96,7 +96,7 @@ export abstract class WidgetOpenHandler<W extends BaseWidget> implements OpenHan
             ...options
         };
         if (!widget.isAttached) {
-            this.shell.addWidget(widget, op.widgetOptions || { area: 'main' });
+            await this.shell.addWidget(widget, op.widgetOptions || { area: 'main' });
         }
         if (op.mode === 'activate') {
             await this.shell.activateWidget(widget.id);
@@ -143,12 +143,12 @@ export abstract class WidgetOpenHandler<W extends BaseWidget> implements OpenHan
 
     protected getWidget(uri: URI, options?: WidgetOpenerOptions): Promise<W | undefined> {
         const widgetOptions = this.createWidgetOptions(uri, options);
-        return this.widgetManager.getWidget<W>(this.id, widgetOptions);
+        return this.widgetManager.getWidget(this.id, widgetOptions);
     }
 
     protected getOrCreateWidget(uri: URI, options?: WidgetOpenerOptions): Promise<W> {
         const widgetOptions = this.createWidgetOptions(uri, options);
-        return this.widgetManager.getOrCreateWidget<W>(this.id, widgetOptions);
+        return this.widgetManager.getOrCreateWidget(this.id, widgetOptions);
     }
 
     protected abstract createWidgetOptions(uri: URI, options?: WidgetOpenerOptions): Object;

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

@@ -25,6 +25,11 @@ export interface PreferenceSchema {
     [name: string]: any,
     scope?: 'application' | 'window' | 'resource' | PreferenceScope,
     overridable?: boolean;
+    /**
+     * The title of the preference schema.
+     * It is used in the preference UI to associate a localized group of preferences.
+     */
+    title?: string;
     properties: PreferenceSchemaProperties
 }
 export namespace PreferenceSchema {

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

@@ -18,7 +18,6 @@ import * as fuzzy from 'fuzzy';
 import { Event } from './event';
 import { KeySequence } from './keys';
 import { CancellationToken } from './cancellation';
-import { URI as Uri } from 'vscode-uri';
 
 export const quickPickServicePath = '/services/quickPick';
 export const QuickPickService = Symbol('QuickPickService');
@@ -53,7 +52,6 @@ export interface QuickPickItem {
     description?: string;
     detail?: string;
     keySequence?: KeySequence;
-    iconPath?: { light?: Uri; dark: Uri };
     iconClasses?: string[];
     alwaysShow?: boolean;
     highlights?: QuickPickItemHighlights;
@@ -94,7 +92,6 @@ export interface QuickPickValue<V> extends QuickPickItem {
 }
 
 export interface QuickInputButton {
-    iconPath?: { light?: Uri; dark: Uri };
     iconClass?: string;
     tooltip?: string;
     /**

package/src/electron-browser/preload.ts

@@ -199,7 +199,7 @@ const api: TheiaCoreAPI = {
         ipcRenderer.send(CHANNEL_TOGGLE_FULL_SCREEN);
     },
 
-    requestReload: () => ipcRenderer.send(CHANNEL_REQUEST_RELOAD),
+    requestReload: (newUrl?: string) => ipcRenderer.send(CHANNEL_REQUEST_RELOAD, newUrl),
     restart: () => ipcRenderer.send(CHANNEL_RESTART),
 
     applicationStateChanged: state => {

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

@@ -100,7 +100,7 @@ export class ElectronWindowService extends DefaultWindowService {
             if (params.hash) {
                 newLocation.hash = '#' + params.hash;
             }
-            location.assign(newLocation);
+            window.electronTheiaCore.requestReload(newLocation.toString());
         } else {
             window.electronTheiaCore.requestReload();
         }

package/src/electron-common/electron-api.ts

@@ -84,7 +84,7 @@ export interface TheiaCoreAPI {
     isFullScreen(): boolean; // TODO: this should really be async, since it blocks the renderer process
     toggleFullScreen(): void;
 
-    requestReload(): void;
+    requestReload(newUrl?: string): void;
     restart(): void;
 
     applicationStateChanged(state: FrontendApplicationState): void;

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

@@ -15,8 +15,10 @@
 // *****************************************************************************
 
 import { inject, injectable, named } from 'inversify';
-import { screen, app, BrowserWindow, WebContents, Event as ElectronEvent, BrowserWindowConstructorOptions, nativeImage,
-    nativeTheme, shell, dialog } from '../../electron-shared/electron';
+import {
+    screen, app, BrowserWindow, WebContents, Event as ElectronEvent, BrowserWindowConstructorOptions, nativeImage,
+    nativeTheme, shell, dialog
+} from '../../electron-shared/electron';
 import * as path from 'path';
 import { Argv } from 'yargs';
 import { AddressInfo } from 'net';
@@ -350,6 +352,9 @@ export class ElectronMainApplication {
             alwaysOnTop: true,
             show: false,
             transparent: true,
+            webPreferences: {
+                backgroundThrottling: false
+            }
         });
 
         if (this.isShowWindowEarly()) {
@@ -458,6 +463,7 @@ export class ElectronMainApplication {
                 // Setting the following option to `true` causes some features to break, somehow.
                 // Issue: https://github.com/eclipse-theia/theia/issues/8577
                 nodeIntegrationInWorker: false,
+                backgroundThrottling: false,
                 preload: path.resolve(this.globals.THEIA_APP_PROJECT_PATH, 'lib', 'frontend', 'preload.js').toString()
             },
             ...this.config.electron?.windowOptions || {},

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

@@ -147,10 +147,14 @@ export class TheiaElectronWindow {
         return this.handleStopRequest(() => this.doCloseWindow(), reason);
     }
 
-    protected reload(): void {
+    protected reload(newUrl?: string): void {
         this.handleStopRequest(async () => {
             this.applicationState = 'init';
-            this._window.reload();
+            if (newUrl) {
+                this._window.loadURL(newUrl);
+            } else {
+                this._window.reload();
+            }
         }, StopReason.Reload);
     }
 
@@ -195,7 +199,7 @@ export class TheiaElectronWindow {
     }
 
     protected attachReloadListener(): void {
-        this.toDispose.push(TheiaRendererAPI.onRequestReload(this.window.webContents, () => this.reload()));
+        this.toDispose.push(TheiaRendererAPI.onRequestReload(this.window.webContents, (newUrl?: string) => this.reload(newUrl)));
     }
 
     dispose(): void {

package/src/node/messaging/websocket-frontend-connection-service.ts

@@ -105,7 +105,8 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
         socket.on('disconnect', evt => {
             console.info('socked closed');
             channel.disconnect();
-            const timeout = BackendApplicationConfigProvider.get().frontendConnectionTimeout;
+
+            const timeout = this.frontendConnectionTimeout();
             const isMarkedForClose = this.channelsMarkedForClose.delete(frontEndId);
             if (timeout === 0 || isMarkedForClose) {
                 this.closeConnection(frontEndId, evt);
@@ -124,6 +125,15 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     markForClose(channelId: string): void {
         this.channelsMarkedForClose.add(channelId);
     }
+
+    private frontendConnectionTimeout(): number {
+        const envValue = Number(process.env['FRONTEND_CONNECTION_TIMEOUT']);
+        if (!isNaN(envValue)) {
+            return envValue;
+        }
+
+        return BackendApplicationConfigProvider.get().frontendConnectionTimeout;
+    }
 }
 
 class ReconnectableSocketChannel extends AbstractChannel {