@theia/core 1.51.0 → 1.53.0-next.18

package/src/browser/shell/split-panels.ts

@@ -91,13 +91,14 @@ export class SplitPositionHandler {
             move.resolve = resolve;
             move.reject = reject;
             if (this.splitMoves.length === 0) {
-                window.requestAnimationFrame(this.animationFrame.bind(this));
+                setTimeout(this.animationFrame.bind(this), 10);
             }
             this.splitMoves.push(move);
         });
     }
 
-    protected animationFrame(time: number): void {
+    protected animationFrame(): void {
+        const time = Date.now();
         const move = this.splitMoves[this.currentMoveIndex];
         let rejectedOrResolved = false;
         if (move.ended || move.referenceWidget && move.referenceWidget.isHidden) {
@@ -133,7 +134,7 @@ export class SplitPositionHandler {
             this.currentMoveIndex = 0;
         }
         if (this.splitMoves.length > 0) {
-            window.requestAnimationFrame(this.animationFrame.bind(this));
+            setTimeout(this.animationFrame.bind(this));
         }
     }
 

package/src/browser/shell/tab-bars.ts

@@ -619,7 +619,7 @@ export class TabBarRenderer extends TabBar.Renderer {
                         cssClasses: ['extended-tab-preview'],
                         visualPreview: this.corePreferences?.['window.tabbar.enhancedPreview'] === 'visual' ? width => this.renderVisualPreview(width, title) : undefined
                     });
-                } else {
+                } else if (title.caption) {
                     this.hoverService.requestHover({
                         content: title.caption,
                         target: event.currentTarget,

package/src/browser/style/index.css

@@ -239,7 +239,8 @@ blockquote {
     -o-user-select: none;
 }
 
-:focus {
+/* Since an iframe has its own focus tracking, we don't show focus on iframes */
+:focus:not(iframe) {
     outline-width: 1px;
     outline-style: solid;
     outline-offset: -1px;
@@ -349,3 +350,4 @@ button.secondary[disabled],
 @import "./progress-bar.css";
 @import "./breadcrumbs.css";
 @import "./tooltip.css";
+@import "./split-widget.css";

package/src/browser/style/split-widget.css

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (C) 2024 1C-Soft LLC 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
+ ********************************************************************************/
+
+.theia-split-widget > .p-SplitPanel {
+  height: 100%;
+  width: 100%;
+  outline: none;
+}
+
+.theia-split-widget > .p-SplitPanel > .p-SplitPanel-child {
+  min-width: 50px;
+  min-height: var(--theia-content-line-height);
+}
+
+.theia-split-widget > .p-SplitPanel > .p-SplitPanel-handle {
+  box-sizing: border-box;
+}
+
+.theia-split-widget > .p-SplitPanel[data-orientation="horizontal"] > .p-SplitPanel-handle {
+  border-left: var(--theia-border-width) solid var(--theia-sideBarSectionHeader-border);
+}
+
+.theia-split-widget > .p-SplitPanel[data-orientation="vertical"] > .p-SplitPanel-handle {
+  border-top: var(--theia-border-width) solid var(--theia-sideBarSectionHeader-border);
+}

package/src/browser/style/tabs.css

@@ -177,6 +177,17 @@
   padding-right: 8px;
 }
 
+.p-TabBar.theia-app-centers .p-TabBar-tabIcon[class*="plugin-icon-"],
+.p-TabBar-tab.p-mod-drag-image .p-TabBar-tabIcon[class*="plugin-icon-"] {
+  background: none;
+  height: var(--theia-icon-size);
+}
+
+.p-TabBar.theia-app-centers .p-TabBar-tabIcon[class*="plugin-icon-"]::before,
+.p-TabBar-tab.p-mod-drag-image .p-TabBar-tabIcon[class*="plugin-icon-"]::before {
+  display: inline-block;
+}
+
 /* codicons */
 .p-TabBar.theia-app-centers .p-TabBar-tabIcon.codicon,
 .p-TabBar-tab.p-mod-drag-image .p-TabBar-tabIcon.codicon {

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

@@ -24,7 +24,10 @@ import { WidgetManager } from './widget-manager';
 
 export type WidgetOpenMode = 'open' | 'reveal' | 'activate';
 /**
- * `WidgetOpenerOptions` define serializable generic options used by the {@link WidgetOpenHandler}.
+ * `WidgetOpenerOptions` define generic options used by the {@link WidgetOpenHandler}.
+ *
+ * _Note:_ This object may contain references to widgets (e.g. `widgetOptions.ref`);
+ * these need to be transformed before it can be serialized.
  */
 export interface WidgetOpenerOptions extends OpenerOptions {
     /**
@@ -96,7 +99,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 +146,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/browser/widgets/index.ts

@@ -18,3 +18,4 @@ export * from './widget';
 export * from './react-renderer';
 export * from './react-widget';
 export * from './extractable-widget';
+export * from './split-widget';

package/src/browser/widgets/split-widget.ts

@@ -0,0 +1,163 @@
+// *****************************************************************************
+// Copyright (C) 2024 1C-Soft LLC 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 { Emitter } from 'vscode-languageserver-protocol';
+import { ApplicationShell, StatefulWidget } from '../shell';
+import { BaseWidget, Message, PanelLayout, SplitPanel, Widget } from './widget';
+import { CompositeSaveable, Saveable, SaveableSource } from '../saveable';
+import { Navigatable } from '../navigatable-types';
+import { URI } from '../../common';
+
+/**
+ * A widget containing a number of panes in a split layout.
+ */
+export class SplitWidget extends BaseWidget implements ApplicationShell.TrackableWidgetProvider, SaveableSource, Navigatable, StatefulWidget {
+
+    protected readonly splitPanel: SplitPanel;
+
+    protected readonly onDidChangeTrackableWidgetsEmitter = new Emitter<Widget[]>();
+    readonly onDidChangeTrackableWidgets = this.onDidChangeTrackableWidgetsEmitter.event;
+
+    protected readonly compositeSaveable = new CompositeSaveable();
+
+    protected navigatable?: Navigatable;
+
+    constructor(options?: SplitPanel.IOptions & { navigatable?: Navigatable }) {
+        super();
+
+        this.toDispose.pushAll([this.onDidChangeTrackableWidgetsEmitter]);
+
+        this.addClass('theia-split-widget');
+
+        const layout = new PanelLayout();
+        this.layout = layout;
+        const that = this;
+        this.splitPanel = new class extends SplitPanel {
+
+            protected override onChildAdded(msg: Widget.ChildMessage): void {
+                super.onChildAdded(msg);
+                that.onPaneAdded(msg.child);
+            }
+
+            protected override onChildRemoved(msg: Widget.ChildMessage): void {
+                super.onChildRemoved(msg);
+                that.onPaneRemoved(msg.child);
+            }
+        }({
+            spacing: 1, // --theia-border-width
+            ...options
+        });
+        this.splitPanel.node.tabIndex = -1;
+        layout.addWidget(this.splitPanel);
+
+        this.navigatable = options?.navigatable;
+    }
+
+    get orientation(): SplitPanel.Orientation {
+        return this.splitPanel.orientation;
+    }
+
+    set orientation(value: SplitPanel.Orientation) {
+        this.splitPanel.orientation = value;
+    }
+
+    relativeSizes(): number[] {
+        return this.splitPanel.relativeSizes();
+    }
+
+    setRelativeSizes(sizes: number[]): void {
+        this.splitPanel.setRelativeSizes(sizes);
+    }
+
+    get handles(): readonly HTMLDivElement[] {
+        return this.splitPanel.handles;
+    }
+
+    get saveable(): Saveable {
+        return this.compositeSaveable;
+    }
+
+    getResourceUri(): URI | undefined {
+        return this.navigatable?.getResourceUri();
+    }
+
+    createMoveToUri(resourceUri: URI): URI | undefined {
+        return this.navigatable?.createMoveToUri(resourceUri);
+    }
+
+    storeState(): SplitWidget.State {
+        return { orientation: this.orientation, widgets: this.panes, relativeSizes: this.relativeSizes() };
+    }
+
+    restoreState(oldState: SplitWidget.State): void {
+        const { orientation, widgets, relativeSizes } = oldState;
+        if (orientation) {
+            this.orientation = orientation;
+        }
+        for (const widget of widgets) {
+            this.addPane(widget);
+        }
+        if (relativeSizes) {
+            this.setRelativeSizes(relativeSizes);
+        }
+    }
+
+    get panes(): readonly Widget[] {
+        return this.splitPanel.widgets;
+    }
+
+    getTrackableWidgets(): Widget[] {
+        return [...this.panes];
+    }
+
+    protected fireDidChangeTrackableWidgets(): void {
+        this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
+    }
+
+    addPane(pane: Widget): void {
+        this.splitPanel.addWidget(pane);
+    }
+
+    insertPane(index: number, pane: Widget): void {
+        this.splitPanel.insertWidget(index, pane);
+    }
+
+    protected onPaneAdded(pane: Widget): void {
+        if (Saveable.isSource(pane)) {
+            this.compositeSaveable.add(pane.saveable);
+        }
+        this.fireDidChangeTrackableWidgets();
+    }
+
+    protected onPaneRemoved(pane: Widget): void {
+        if (Saveable.isSource(pane)) {
+            this.compositeSaveable.remove(pane.saveable);
+        }
+        this.fireDidChangeTrackableWidgets();
+    }
+
+    protected override onActivateRequest(msg: Message): void {
+        this.splitPanel.node.focus();
+    }
+}
+
+export namespace SplitWidget {
+    export interface State {
+        orientation?: SplitPanel.Orientation;
+        widgets: readonly Widget[]; // note: don't rename this property; it has special meaning for `ShellLayoutRestorer`
+        relativeSizes?: number[];
+    }
+}

package/src/common/event.ts

@@ -89,6 +89,12 @@ export namespace Event {
         return new Promise(resolve => once(event)(resolve));
     }
 
+    export function filter<T>(event: Event<T>, predicate: (e: T) => unknown): Event<T>;
+    export function filter<T, S extends T>(event: Event<T>, predicate: (e: T) => e is S): Event<S>;
+    export function filter<T>(event: Event<T>, predicate: (e: T) => unknown): Event<T> {
+        return (listener, thisArg, disposables) => event(e => predicate(e) && listener.call(thisArg, e), undefined, disposables);
+    }
+
     /**
      * Given an event and a `map` function, returns another event which maps each element
      * through the mapping function.

package/src/common/json-schema.ts

@@ -36,6 +36,8 @@ export interface IJSONSchema {
     $id?: string;
     $schema?: string;
     type?: JsonType | JsonType[];
+    owner?: string;
+    group?: string;
     title?: string;
     default?: JSONValue;
     definitions?: IJSONSchemaMap;

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 {