@theia/core 1.42.1 → 1.43.0

package/src/browser/menu/browser-menu-module.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { ContextMenuRenderer } from '../context-menu-renderer';
 import { BrowserMenuBarContribution, BrowserMainMenuFactory } from './browser-menu-plugin';
 import { BrowserContextMenuRenderer } from './browser-context-menu-renderer';

package/src/browser/menu/browser-menu-plugin.ts

@@ -22,7 +22,8 @@ import {
     MenuModelRegistry, MAIN_MENU_BAR, MenuPath, MenuNode, MenuCommandExecutor, CompoundMenuNode, CompoundMenuNodeRole, CommandMenuNode
 } from '../../common';
 import { KeybindingRegistry } from '../keybinding';
-import { FrontendApplicationContribution, FrontendApplication } from '../frontend-application';
+import { FrontendApplication } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { ContextKeyService, ContextMatcher } from '../context-key-service';
 import { ContextMenuContext } from './context-menu-context';
 import { waitForRevealed } from '../widgets';

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

@@ -15,8 +15,9 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { WebSocketConnectionProvider } from './ws-connection-provider';
+import { LocalWebSocketConnectionProvider, WebSocketConnectionProvider } from './ws-connection-provider';
 
 export const messagingFrontendModule = new ContainerModule(bind => {
     bind(WebSocketConnectionProvider).toSelf().inSingletonScope();
+    bind(LocalWebSocketConnectionProvider).toService(WebSocketConnectionProvider);
 });

package/src/browser/messaging/ws-connection-provider.ts

@@ -24,6 +24,8 @@ import { IWebSocket, WebSocketChannel } from '../../common/messaging/web-socket-
 decorate(injectable(), RpcProxyFactory);
 decorate(unmanaged(), RpcProxyFactory, 0);
 
+export const LocalWebSocketConnectionProvider = Symbol('LocalWebSocketConnectionProvider');
+
 export interface WebSocketOptions {
     /**
      * True by default.
@@ -48,6 +50,19 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
         return container.get(WebSocketConnectionProvider).createProxy<T>(path, arg);
     }
 
+    static createLocalProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
+        return container.get<WebSocketConnectionProvider>(LocalWebSocketConnectionProvider).createProxy<T>(path, arg);
+    }
+
+    static createHandler(container: interfaces.Container, path: string, arg?: object): void {
+        const remote = container.get(WebSocketConnectionProvider);
+        const local = container.get<WebSocketConnectionProvider>(LocalWebSocketConnectionProvider);
+        remote.createProxy(path, arg);
+        if (remote !== local) {
+            local.createProxy(path, arg);
+        }
+    }
+
     protected readonly socket: Socket;
 
     constructor() {
@@ -104,11 +119,15 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
     protected createWebSocketUrl(path: string): string {
         // Since we are using Socket.io, the path should look like the following:
         // proto://domain.com/{path}
-        return new Endpoint().getWebSocketUrl().withPath(path).toString();
+        return this.createEndpoint(path).getWebSocketUrl().toString();
     }
 
     protected createHttpWebSocketUrl(path: string): string {
-        return new Endpoint({ path }).getRestUrl().toString();
+        return this.createEndpoint(path).getRestUrl().toString();
+    }
+
+    protected createEndpoint(path: string): Endpoint {
+        return new Endpoint({ path });
     }
 
     /**

package/src/browser/quick-input/quick-command-frontend-contribution.ts

@@ -59,6 +59,11 @@ export class QuickCommandFrontendContribution implements CommandContribution, Ke
             commandId: quickCommand.id,
             label: nls.localizeByDefault('Command Palette...')
         });
+        menus.registerMenuAction(CommonMenus.MANAGE_GENERAL, {
+            commandId: quickCommand.id,
+            label: nls.localizeByDefault('Command Palette...'),
+            order: '0'
+        });
     }
 
     registerKeybindings(keybindings: KeybindingRegistry): void {

package/src/browser/quick-input/quick-input-frontend-contribution.ts

@@ -16,7 +16,7 @@
 
 import { injectable, inject, named } from 'inversify';
 import { ContributionProvider } from '../../common';
-import { FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { QuickAccessContribution } from './quick-access';
 
 @injectable()

package/src/browser/saveable.ts

@@ -50,7 +50,7 @@ export interface SaveableSource {
     readonly saveable: Saveable;
 }
 
-export class SaveableDelegate implements Saveable {
+export class DelegatingSaveable implements Saveable {
     dirty = false;
     protected readonly onDirtyChangedEmitter = new Emitter<void>();
 
@@ -60,20 +60,20 @@ export class SaveableDelegate implements Saveable {
     autoSave: 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange' = 'off';
 
     async save(options?: SaveOptions): Promise<void> {
-        await this.delegate?.save(options);
+        await this._delegate?.save(options);
     }
 
     revert?(options?: Saveable.RevertOptions): Promise<void>;
     createSnapshot?(): Saveable.Snapshot;
     applySnapshot?(snapshot: object): void;
 
-    protected delegate?: Saveable;
+    protected _delegate?: Saveable;
     protected toDispose?: Disposable;
 
-    set(delegate: Saveable): void {
+    set delegate(delegate: Saveable) {
         this.toDispose?.dispose();
-        this.delegate = delegate;
-        this.toDispose = this.delegate.onDirtyChanged(() => {
+        this._delegate = delegate;
+        this.toDispose = delegate.onDirtyChanged(() => {
             this.dirty = delegate.dirty;
             this.onDirtyChangedEmitter.fire();
         });
@@ -164,8 +164,12 @@ export namespace Saveable {
                 if (typeof result === 'boolean') {
                     if (result) {
                         await (doSave?.(this) ?? Saveable.save(this));
+                        if (!isDirty(this)) {
+                            await this.closeWithoutSaving();
+                        }
+                    } else {
+                        await this.closeWithoutSaving();
                     }
-                    await this.closeWithoutSaving();
                 }
             } finally {
                 closing = false;

package/src/browser/shell/application-shell-mouse-tracker.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { ApplicationShell } from './application-shell';
 import { injectable, inject } from 'inversify';
 import { DisposableCollection, Disposable } from '../../common/disposable';

package/src/browser/shell/application-shell.ts

@@ -272,6 +272,22 @@ export class ApplicationShell extends Widget {
         @inject(SecondaryWindowHandler) protected readonly secondaryWindowHandler: SecondaryWindowHandler,
     ) {
         super(options as Widget.IOptions);
+
+        // Merge the user-defined application options with the default options
+        this.options = {
+            bottomPanel: {
+                ...ApplicationShell.DEFAULT_OPTIONS.bottomPanel,
+                ...options?.bottomPanel || {}
+            },
+            leftPanel: {
+                ...ApplicationShell.DEFAULT_OPTIONS.leftPanel,
+                ...options?.leftPanel || {}
+            },
+            rightPanel: {
+                ...ApplicationShell.DEFAULT_OPTIONS.rightPanel,
+                ...options?.rightPanel || {}
+            }
+        };
     }
 
     @postConstruct()
@@ -303,21 +319,6 @@ export class ApplicationShell extends Widget {
     protected initializeShell(): void {
         this.addClass(APPLICATION_SHELL_CLASS);
         this.id = 'theia-app-shell';
-        // Merge the user-defined application options with the default options
-        this.options = {
-            bottomPanel: {
-                ...ApplicationShell.DEFAULT_OPTIONS.bottomPanel,
-                ...this.options?.bottomPanel || {}
-            },
-            leftPanel: {
-                ...ApplicationShell.DEFAULT_OPTIONS.leftPanel,
-                ...this.options?.leftPanel || {}
-            },
-            rightPanel: {
-                ...ApplicationShell.DEFAULT_OPTIONS.rightPanel,
-                ...this.options?.rightPanel || {}
-            }
-        };
 
         this.mainPanel = this.createMainPanel();
         this.topPanel = this.createTopPanel();

package/src/browser/shell/tab-bar-decorator.ts

@@ -19,7 +19,7 @@ import { Title, Widget } from '@phosphor/widgets';
 import { inject, injectable, named } from 'inversify';
 import { Event, Emitter, ContributionProvider } from '../../common';
 import { WidgetDecoration } from '../widget-decoration';
-import { FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 
 export const TabBarDecorator = Symbol('TabBarDecorator');
 

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -19,7 +19,7 @@ import { inject, injectable, named } from 'inversify';
 // eslint-disable-next-line max-len
 import { CommandMenuNode, CommandRegistry, CompoundMenuNode, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuNode, MenuPath } from '../../../common';
 import { ContextKeyService } from '../../context-key-service';
-import { FrontendApplicationContribution } from '../../frontend-application';
+import { FrontendApplicationContribution } from '../../frontend-application-contribution';
 import { Widget } from '../../widgets';
 import { AnyToolbarItem, ConditionalToolbarItem, MenuDelegate, MenuToolbarItem, ReactTabBarToolbarItem, TabBarToolbarItem } from './tab-bar-toolbar-types';
 import { ToolbarMenuNodeWrapper } from './tab-bar-toolbar-menu-adapters';

package/src/browser/status-bar/status-bar.tsx

@@ -151,6 +151,9 @@ export class StatusBarImpl extends ReactWidget implements StatusBar {
         } else {
             attrs['aria-label'] = [entry.text, entry.tooltip].join(', ');
         }
+        if (entry.backgroundColor) {
+            attrs.className += ' has-background';
+        }
 
         attrs.style = {
             color: entry.color || this.color,
@@ -178,8 +181,9 @@ export class StatusBarImpl extends ReactWidget implements StatusBar {
                 children.push(<span key={key}>{val}</span>);
             }
         });
-        const elementInnerDiv = <React.Fragment>{children}</React.Fragment>;
-        return React.createElement('div', { key: entry.id, ...this.createAttributes(entry) }, elementInnerDiv);
+        return <div key={entry.id} {...this.createAttributes(entry)}>
+            {children}
+        </div>;
     }
 
 }

package/src/browser/style/status-bar.css

@@ -30,7 +30,7 @@ body.theia-no-open-workspace #theia-statusBar {
   background: var(--theia-statusBar-noFolderBackground);
   color: var(--theia-statusBar-noFolderForeground);
   border-top: var(--theia-border-width) solid
-    var(--theia-statusBar-noFolderBorder);
+  var(--theia-statusBar-noFolderBorder);
 }
 
 #theia-statusBar .area {
@@ -41,7 +41,6 @@ body.theia-no-open-workspace #theia-statusBar {
 
 #theia-statusBar .area.left {
   justify-content: flex-start;
-  padding-left: calc(var(--theia-ui-padding) * 2);
 }
 
 #theia-statusBar .area.right {
@@ -56,8 +55,14 @@ body.theia-no-open-workspace #theia-statusBar {
   font-size: var(--theia-statusBar-font-size);
 }
 
-#theia-statusBar .area .element > * {
-  margin-left: calc(var(--theia-ui-padding) / 2);
+#theia-statusBar .area.left .element.has-background {
+  margin-left: 0px;
+  margin-right: 3px;
+  padding-left: 7px;
+  padding-right: 7px;
+}
+#theia-statusBar .area .element>* {
+  margin-left: calc(var(--theia-ui-padding)/2);
 }
 
 #theia-statusBar .area .element .codicon {
@@ -77,6 +82,9 @@ body.theia-no-open-workspace #theia-statusBar {
   color: var(--theia-statusBar-offlineForeground) !important;
 }
 
+#theia-statusBar .area.left .element:first-child:not(.has-background) {
+    margin-left: calc(var(--theia-ui-padding) * 3);
+}
 #theia-statusBar .area.left .element {
   margin-right: var(--theia-ui-padding);
 }

package/src/browser/styling-service.ts

@@ -19,7 +19,7 @@ import { ContributionProvider } from '../common/contribution-provider';
 import { Theme, ThemeType } from '../common/theme';
 import { ColorRegistry } from './color-registry';
 import { DecorationStyle } from './decoration-style';
-import { FrontendApplicationContribution } from './frontend-application';
+import { FrontendApplicationContribution } from './frontend-application-contribution';
 import { ThemeService } from './theming';
 import { Disposable } from '../common';
 

package/src/browser/window/browser-window-module.ts

@@ -17,7 +17,7 @@
 import { ContainerModule } from 'inversify';
 import { WindowService } from '../../browser/window/window-service';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
-import { FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { ClipboardService } from '../clipboard-service';
 import { BrowserClipboardService } from '../browser-clipboard-service';
 import { SecondaryWindowService } from './secondary-window-service';

package/src/browser/window/default-window-service.spec.ts

@@ -17,7 +17,7 @@
 import { Container } from 'inversify';
 import { ContributionProvider } from '../../common';
 import { CorePreferences } from '../core-preferences';
-import { FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { DefaultWindowService } from './default-window-service';
 import assert = require('assert');
 

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

@@ -18,11 +18,12 @@ import { inject, injectable, named } from 'inversify';
 import { Event, Emitter } from '../../common';
 import { CorePreferences } from '../core-preferences';
 import { ContributionProvider } from '../../common/contribution-provider';
-import { FrontendApplicationContribution, FrontendApplication, OnWillStopAction } from '../frontend-application';
+import { FrontendApplicationContribution, OnWillStopAction } from '../frontend-application-contribution';
 import { WindowService } from './window-service';
 import { DEFAULT_WINDOW_HASH } from '../../common/window';
 import { confirmExit } from '../dialogs';
 import { StopReason } from '../../common/frontend-application-state';
+import { FrontendApplication } from '../frontend-application';
 
 @injectable()
 export class DefaultWindowService implements WindowService, FrontendApplicationContribution {

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

@@ -16,7 +16,7 @@
 
 import { StopReason } from '../../common/frontend-application-state';
 import { Event } from '../../common/event';
-import { NewWindowOptions } from '../../common/window';
+import { NewWindowOptions, WindowSearchParams } from '../../common/window';
 
 /**
  * Service for opening new browser windows.
@@ -35,7 +35,7 @@ export interface WindowService {
      * Opens a new default window.
      * - In electron and in the browser it will open the default window without a pre-defined content.
      */
-    openNewDefaultWindow(): void;
+    openNewDefaultWindow(params?: WindowSearchParams): void;
 
     /**
      * Fires when the `window` unloads. The unload event is inevitable. On this event, the frontend application can save its state and release resource.
@@ -64,5 +64,5 @@ export interface WindowService {
     /**
      * Reloads the window according to platform.
      */
-    reload(): void;
+    reload(params?: WindowSearchParams): void;
 }

package/src/browser/window/window-title-updater.ts

@@ -15,7 +15,8 @@
 // *****************************************************************************
 
 import { Widget } from '../widgets';
-import { FrontendApplication, FrontendApplicationContribution } from '../frontend-application';
+import { FrontendApplication } from '../frontend-application';
+import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { NavigatableWidget } from '../navigatable-types';
 import { inject, injectable } from 'inversify';
 import { WindowTitleService } from './window-title-service';

package/src/common/cancellation.ts

@@ -20,6 +20,7 @@
 
 import { Event, Emitter } from './event';
 import { isBoolean, isObject } from './types';
+import { Disposable } from './disposable';
 
 export interface CancellationToken {
     readonly isCancellationRequested: boolean;
@@ -93,11 +94,23 @@ class MutableToken implements CancellationToken {
         }
         return this._emitter.event;
     }
+
+    public dispose(): void {
+        if (this._emitter) {
+            this._emitter.dispose();
+            this._emitter = undefined;
+        }
+    }
 }
 
 export class CancellationTokenSource {
 
     private _token: CancellationToken;
+    private _parentListener?: Disposable = undefined;
+
+    constructor(parent?: CancellationToken) {
+        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);
+    }
 
     get token(): CancellationToken {
         if (!this._token) {
@@ -121,6 +134,15 @@ export class CancellationTokenSource {
 
     dispose(): void {
         this.cancel();
+        this._parentListener?.dispose();
+        if (!this._token) {
+            // ensure to initialize with an empty token if we had none
+            this._token = CancellationToken.None;
+
+        } else if (this._token instanceof MutableToken) {
+            // actually dispose
+            this._token.dispose();
+        }
     }
 }
 

package/src/common/collections.ts

@@ -0,0 +1,125 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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
+// *****************************************************************************
+
+/**
+ * A convenience class for managing a "map of maps" of arbitrary depth
+ */
+export class MultiKeyMap<K, V> {
+    private rootMap = new Map();
+
+    constructor(private readonly keyLength: number) {
+    }
+
+    static create<S, T>(keyLength: number, data: [S[], T][]): MultiKeyMap<S, T> {
+        const result = new MultiKeyMap<S, T>(keyLength);
+        for (const entry of data) {
+            result.set(entry[0], entry[1]);
+        }
+        return result;
+    }
+
+    set(key: readonly K[], value: V): V | undefined {
+        if (this.keyLength !== key.length) {
+            throw new Error(`inappropriate key length: ${key.length}, should be ${this.keyLength}`);
+        }
+        let map = this.rootMap;
+        for (let i = 0; i < this.keyLength - 1; i++) {
+            let existing = map.get(key[i]);
+            if (!existing) {
+                existing = new Map();
+                map.set(key[i], existing);
+            }
+            map = existing;
+        }
+        const oldValue = map.get(key[this.keyLength - 1]);
+        map.set(key[this.keyLength - 1], value);
+        return oldValue;
+    }
+
+    get(key: readonly K[]): V | undefined {
+        if (this.keyLength !== key.length) {
+            throw new Error(`inappropriate key length: ${key.length}, should be ${this.keyLength}`);
+        }
+        let map = this.rootMap;
+        for (let i = 0; i < this.keyLength - 1; i++) {
+            map = map.get(key[i]);
+            if (!map) {
+                return undefined;
+            }
+        }
+        return map.get(key[this.keyLength - 1]);
+    }
+
+    /**
+     * Checks whether the given key is present in the map
+     * @param key the key to test. It can have a length < the key length
+     * @returns whether the key exists
+     */
+    has(key: readonly K[]): boolean {
+        if (this.keyLength < key.length) {
+            throw new Error(`inappropriate key length: ${key.length}, should <= ${this.keyLength}`);
+        }
+        let map = this.rootMap;
+        for (let i = 0; i < key.length - 1; i++) {
+            map = map.get(key[i]);
+            if (!map) {
+                return false;
+            }
+        }
+        return map.has(key[key.length - 1]);
+    }
+
+    /**
+     * Deletes the value with the given key from the map
+     * @param key the key to remove.  It can have a length < the key length
+     * @returns whether the key was present in the map
+     */
+    delete(key: readonly K[]): boolean {
+        if (this.keyLength < key.length) {
+            throw new Error(`inappropriate key length: ${key.length}, should <= ${this.keyLength}`);
+        }
+        let map = this.rootMap;
+        for (let i = 0; i < this.keyLength - 1; i++) {
+            map = map.get(key[i]);
+            if (!map) {
+                return false;
+            }
+        }
+        return map.delete(key[key.length - 1]);
+    }
+
+    /**
+     * Iterates over all entries in the map. The ordering semantics are like iterating over a map of maps.
+     * @param handler Handler for each entry
+     */
+    forEach(handler: (value: V, key: K[]) => void): void {
+        this.doForeach(handler, this.rootMap, []);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    private doForeach(handler: (value: V, key: K[]) => void, currentMap: Map<any, any>, keys: K[]): void {
+        if (keys.length === this.keyLength - 1) {
+            currentMap.forEach((v, k) => {
+                handler(v, [...keys, k]);
+            });
+        } else {
+            currentMap.forEach((v, k) => {
+                this.doForeach(handler, v, [...keys, k]);
+            });
+
+        }
+    }
+}

package/src/common/event.ts

@@ -57,6 +57,38 @@ export namespace Event {
         set maxListeners(maxListeners: number) { }
     });
 
+    /**
+     * Given an event, returns another event which only fires once.
+     */
+    export function once<T>(event: Event<T>): Event<T> {
+        return (listener, thisArgs = undefined, disposables?) => {
+            // we need this, in case the event fires during the listener call
+            let didFire = false;
+            let result: Disposable | undefined = undefined;
+            result = event(e => {
+                if (didFire) {
+                    return;
+                } else if (result) {
+                    result.dispose();
+                } else {
+                    didFire = true;
+                }
+
+                return listener.call(thisArgs, e);
+            }, undefined, disposables);
+
+            if (didFire) {
+                result.dispose();
+            }
+
+            return result;
+        };
+    }
+
+    export function toPromise<T>(event: Event<T>): Promise<T> {
+        return new Promise(resolve => once(event)(resolve));
+    }
+
     /**
      * Given an event and a `map` function, returns another event which maps each element
      * through the mapping function.