@theia/core 1.45.0 → 1.46.0

package/src/browser/tree/index.ts

@@ -26,3 +26,4 @@ export * from './tree-container';
 export * from './tree-decorator';
 export * from './tree-search';
 export * from './tree-compression';
+export * from './tree-preference';

package/src/browser/tree/tree-preference.ts

@@ -0,0 +1,50 @@
+// *****************************************************************************
+// Copyright (C) 2024 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
+// *****************************************************************************
+
+import { interfaces } from 'inversify';
+import { PreferenceProxy, PreferenceContribution, PreferenceSchema } from '../preferences';
+import { PreferenceProxyFactory } from '../preferences/injectable-preference-proxy';
+import { nls } from '../../common/nls';
+
+export const PREFERENCE_NAME_TREE_INDENT = 'workbench.tree.indent';
+
+export const treePreferencesSchema: PreferenceSchema = {
+    type: 'object',
+    properties: {
+        [PREFERENCE_NAME_TREE_INDENT]: {
+            description: nls.localizeByDefault('Controls tree indentation in pixels.'),
+            type: 'number',
+            default: 8,
+            minimum: 4,
+            maximum: 40
+        },
+    }
+};
+
+export class TreeConfiguration {
+    [PREFERENCE_NAME_TREE_INDENT]: number;
+}
+
+export const TreePreferences = Symbol('treePreferences');
+export type TreePreferences = PreferenceProxy<TreeConfiguration>;
+
+export function bindTreePreferences(bind: interfaces.Bind): void {
+    bind(TreePreferences).toDynamicValue(ctx => {
+        const factory = ctx.container.get<PreferenceProxyFactory>(PreferenceProxyFactory);
+        return factory(treePreferencesSchema);
+    }).inSingletonScope();
+    bind(PreferenceContribution).toConstantValue({ schema: treePreferencesSchema });
+}

package/src/browser/tree/tree-widget.tsx

@@ -43,6 +43,8 @@ import { LabelProvider } from '../label-provider';
 import { CorePreferences } from '../core-preferences';
 import { TreeFocusService } from './tree-focus-service';
 import { useEffect } from 'react';
+import { PreferenceService, PreferenceChange } from '../preferences';
+import { PREFERENCE_NAME_TREE_INDENT } from './tree-preference';
 
 const debounce = require('lodash.debounce');
 
@@ -73,8 +75,7 @@ export interface TreeProps {
     readonly contextMenuPath?: MenuPath;
 
     /**
-     * The size of the padding (in pixels) per hierarchy depth. The root element won't have left padding but
-     * the padding for the children will be calculated as `leftPadding * hierarchyDepth` and so on.
+     * The size of the padding (in pixels) for the root node of the tree.
      */
     readonly leftPadding: number;
 
@@ -174,6 +175,9 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
     @inject(SelectionService)
     protected readonly selectionService: SelectionService;
 
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
     @inject(LabelProvider)
     protected readonly labelProvider: LabelProvider;
 
@@ -182,6 +186,8 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
 
     protected shouldScrollToRow = true;
 
+    protected treeIndent: number = 8;
+
     constructor(
         @inject(TreeProps) readonly props: TreeProps,
         @inject(TreeModel) readonly model: TreeModel,
@@ -198,6 +204,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
 
     @postConstruct()
     protected init(): void {
+        this.treeIndent = this.preferenceService.get(PREFERENCE_NAME_TREE_INDENT, this.treeIndent);
         if (this.props.search) {
             this.searchBox = this.searchBoxFactory({ ...SearchBoxProps.DEFAULT, showButtons: true, showFilter: true });
             this.searchBox.node.addEventListener('focus', () => {
@@ -264,6 +271,12 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                         return;
                     }
                 }
+            }),
+            this.preferenceService.onPreferenceChanged((event: PreferenceChange) => {
+                if (event.preferenceName === PREFERENCE_NAME_TREE_INDENT) {
+                    this.treeIndent = event.newValue;
+                    this.update();
+                }
             })
         ]);
         setTimeout(() => {
@@ -1227,12 +1240,15 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
 
     /**
      * Handle the `space key` keyboard event.
-     * - By default should be similar to a single-click action.
+     * - If the element has a checkbox, it will be toggled.
+     * - Otherwise, it should be similar to a single-click action.
      * @param event the `space key` keyboard event.
      */
     protected handleSpace(event: KeyboardEvent): void {
         const { focusedNode } = this.focusService;
-        if (!this.props.multiSelect || (!event.ctrlKey && !event.metaKey && !event.shiftKey)) {
+        if (focusedNode && focusedNode.checkboxInfo) {
+            this.model.markAsChecked(focusedNode, !focusedNode.checkboxInfo.checked);
+        } else if (!this.props.multiSelect || (!event.ctrlKey && !event.metaKey && !event.shiftKey)) {
             this.tapNode(focusedNode);
         }
     }
@@ -1497,7 +1513,10 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
         return this.labelProvider.getLongName(node);
     }
     protected getDepthPadding(depth: number): number {
-        return depth * this.props.leftPadding;
+        if (depth === 1) {
+            return this.props.leftPadding;
+        }
+        return depth * this.treeIndent;
     }
 }
 export namespace TreeWidget {

package/src/browser/tree/tree.ts

@@ -397,9 +397,10 @@ export class TreeImpl implements Tree {
 
     protected async doMarkAsBusy(node: Mutable<TreeNode>, ms: number, token: CancellationToken): Promise<void> {
         try {
+            token.onCancellationRequested(() => this.doResetBusy(node));
             await timeout(ms, token);
+            if (token.isCancellationRequested) { return; }
             this.doSetBusy(node);
-            token.onCancellationRequested(() => this.doResetBusy(node));
         } catch {
             /* no-op */
         }

package/src/browser/widget-manager.ts

@@ -194,6 +194,31 @@ export class WidgetManager {
         return widget;
     }
 
+    /**
+     * Finds a widget that matches the given test predicate.
+     * @param factoryId The widget factory id.
+     * @param predicate The test predicate.
+     *
+     * @returns a promise resolving to the widget if available, else `undefined`.
+     */
+    async findWidget<T extends Widget>(factoryId: string, predicate: (options?: any) => boolean): Promise<T | undefined> {
+        for (const [key, widget] of this.widgets.entries()) {
+            if (this.testPredicate(key, factoryId, predicate)) {
+                return widget as T;
+            }
+        }
+        for (const [key, widget] of this.pendingWidgetPromises.entries()) {
+            if (this.testPredicate(key, factoryId, predicate)) {
+                return widget as T;
+            }
+        }
+    }
+
+    protected testPredicate(key: string, factoryId: string, predicate: (options?: any) => boolean): boolean {
+        const constructionOptions = this.fromKey(key);
+        return constructionOptions.factoryId === factoryId && predicate(constructionOptions.options);
+    }
+
     protected doGetWidget<T extends Widget>(key: string): MaybePromise<T> | undefined {
         const pendingWidget = this.widgets.get(key) ?? this.pendingWidgetPromises.get(key);
         if (pendingWidget) {

package/src/browser/widgets/select-component.tsx

@@ -77,6 +77,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         if (!list) {
             list = document.createElement('div');
             list.id = SELECT_COMPONENT_CONTAINER;
+            list.className = 'theia-select-component-container';
             document.body.appendChild(list);
         }
         this.dropdownElement = list;

package/src/browser-only/frontend-only-application-module.ts

@@ -0,0 +1,115 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule } from 'inversify';
+import { BackendStopwatch, CommandRegistry, Emitter, MeasurementOptions, OS } from '../common';
+import { ApplicationInfo, ApplicationServer, ExtensionInfo } from '../common/application-protocol';
+import { EnvVariable, EnvVariablesServer } from './../common/env-variables';
+import { bindMessageService } from '../browser/frontend-application-bindings';
+import { KeyStoreService } from '../common/key-store';
+import { QuickPickService } from '../common/quick-pick-service';
+import { QuickPickServiceImpl } from '../browser/quick-input';
+import { BackendRequestService, RequestService } from '@theia/request';
+import { ConnectionStatus, ConnectionStatusService } from '../browser/connection-status-service';
+
+export { bindMessageService };
+
+// is loaded directly after the regular frontend module
+export const frontendOnlyApplicationModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+
+    if (isBound(CommandRegistry)) {
+        rebind(CommandRegistry).toSelf().inSingletonScope();
+    } else {
+        bind(CommandRegistry).toSelf().inSingletonScope();
+    }
+
+    const stopwatch: BackendStopwatch = {
+        start: async (_name: string, _options?: MeasurementOptions | undefined): Promise<number> => -1,
+        stop: async (_measurement: number, _message: string, _messageArgs: unknown[]): Promise<void> => { }
+    };
+    if (isBound(BackendStopwatch)) {
+        rebind(BackendStopwatch).toConstantValue(stopwatch);
+    } else {
+        bind(BackendStopwatch).toConstantValue(stopwatch);
+    }
+
+    if (isBound(CommandRegistry)) {
+        rebind(QuickPickService).to(QuickPickServiceImpl).inSingletonScope();
+    } else {
+        bind(QuickPickService).to(QuickPickServiceImpl).inSingletonScope();
+    }
+
+    const mockedApplicationServer: ApplicationServer = {
+        getExtensionsInfos: async (): Promise<ExtensionInfo[]> => [],
+        getApplicationInfo: async (): Promise<ApplicationInfo | undefined> => undefined,
+        getApplicationRoot: async (): Promise<string> => '',
+        getBackendOS: async (): Promise<OS.Type> => OS.Type.Linux
+    };
+    if (isBound(ApplicationServer)) {
+        rebind(ApplicationServer).toConstantValue(mockedApplicationServer);
+    } else {
+        bind(ApplicationServer).toConstantValue(mockedApplicationServer);
+    }
+
+    const varServer: EnvVariablesServer = {
+        getExecPath: async (): Promise<string> => '',
+        getVariables: async (): Promise<EnvVariable[]> => [],
+        getValue: async (_key: string): Promise<EnvVariable | undefined> => undefined,
+        getConfigDirUri: async (): Promise<string> => '',
+        getHomeDirUri: async (): Promise<string> => '',
+        getDrives: async (): Promise<string[]> => []
+    };
+    if (isBound(EnvVariablesServer)) {
+        rebind(EnvVariablesServer).toConstantValue(varServer);
+    } else {
+        bind(EnvVariablesServer).toConstantValue(varServer);
+    }
+
+    const keyStoreService: KeyStoreService = {
+        deletePassword: () => Promise.resolve(false),
+        findCredentials: () => Promise.resolve([]),
+        findPassword: () => Promise.resolve(undefined),
+        setPassword: () => Promise.resolve(),
+        getPassword: () => Promise.resolve(undefined)
+    };
+    if (isBound(KeyStoreService)) {
+        rebind<KeyStoreService>(KeyStoreService).toConstantValue(keyStoreService);
+    } else {
+        bind<KeyStoreService>(KeyStoreService).toConstantValue(keyStoreService);
+    }
+
+    const requestService: RequestService = {
+        configure: () => Promise.resolve(),
+        request: () => Promise.reject(),
+        resolveProxy: () => Promise.resolve(undefined)
+    };
+    if (isBound(BackendRequestService)) {
+        rebind<RequestService>(BackendRequestService).toConstantValue(requestService);
+    } else {
+        bind<RequestService>(BackendRequestService).toConstantValue(requestService);
+    }
+
+    const connectionStatusService: ConnectionStatusService = {
+        currentStatus: ConnectionStatus.ONLINE,
+        onStatusChange: new Emitter<ConnectionStatus>().event
+    };
+    if (isBound(ConnectionStatusService)) {
+        rebind<ConnectionStatusService>(ConnectionStatusService).toConstantValue(connectionStatusService);
+    } else {
+        bind<ConnectionStatusService>(ConnectionStatusService).toConstantValue(connectionStatusService);
+    }
+
+});

package/src/browser-only/i18n/i18n-frontend-only-module.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule } from 'inversify';
+import { AsyncLocalizationProvider, LanguageInfo, Localization } from '../../common/i18n/localization';
+import { LanguageQuickPickService } from '../../browser/i18n/language-quick-pick-service';
+
+export default new ContainerModule(bind => {
+    const i18nMock: AsyncLocalizationProvider = {
+        getCurrentLanguage: async (): Promise<string> => 'en',
+        setCurrentLanguage: async (_languageId: string): Promise<void> => {
+
+        },
+        getAvailableLanguages: async (): Promise<LanguageInfo[]> =>
+            []
+        ,
+        loadLocalization: async (_languageId: string): Promise<Localization> => ({
+            translations: {},
+            languageId: 'en'
+        })
+    };
+    bind(AsyncLocalizationProvider).toConstantValue(i18nMock);
+    bind(LanguageQuickPickService).toSelf().inSingletonScope();
+});

package/src/browser-only/logger-frontend-only-module.ts

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule, Container } from 'inversify';
+import { ILoggerServer, ILoggerClient, LogLevel, ConsoleLogger } from '../common/logger-protocol';
+import { ILogger, Logger, LoggerFactory, LoggerName } from '../common/logger';
+
+// is loaded directly after the regular logger frontend module
+export const loggerFrontendOnlyModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    const logger: ILoggerServer = {
+        setLogLevel: async (_name: string, _logLevel: number): Promise<void> => { },
+        getLogLevel: async (_name: string): Promise<number> => LogLevel.INFO,
+        log: async (name: string, logLevel: number, message: string, params: unknown[]): Promise<void> => {
+            ConsoleLogger.log(name, logLevel, message, params);
+
+        },
+        child: async (_name: string): Promise<void> => { },
+        dispose: (): void => {
+        },
+        setClient: (_client: ILoggerClient | undefined): void => {
+        }
+    };
+    if (isBound(ILoggerServer)) {
+        rebind(ILoggerServer).toConstantValue(logger);
+    } else {
+        bind(ILoggerServer).toConstantValue(logger);
+    }
+
+    if (isBound(ILoggerServer)) {
+        rebind(LoggerFactory).toFactory(ctx =>
+            (name: string) => {
+                const child = new Container({ defaultScope: 'Singleton' });
+                child.parent = ctx.container;
+                child.bind(ILogger).to(Logger).inTransientScope();
+                child.bind(LoggerName).toConstantValue(name);
+                return child.get(ILogger);
+            }
+        );
+    } else {
+        bind(LoggerFactory).toFactory(ctx =>
+            (name: string) => {
+                const child = new Container({ defaultScope: 'Singleton' });
+                child.parent = ctx.container;
+                child.bind(ILogger).to(Logger).inTransientScope();
+                child.bind(LoggerName).toConstantValue(name);
+                return child.get(ILogger);
+            }
+        );
+    }
+});

package/src/browser-only/messaging/frontend-only-service-connection-provider.ts

@@ -0,0 +1,39 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { Event, RpcProxy, Channel, RpcProxyFactory, Emitter } from '../../common';
+import { injectable } from 'inversify';
+import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+
+@injectable()
+export class FrontendOnlyConnectionSource implements ConnectionSource {
+    onConnectionDidOpen = new Emitter<Channel>().event;
+}
+
+@injectable()
+export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProvider {
+    onSocketDidOpen = Event.None;
+    onSocketDidClose = Event.None;
+    onIncomingMessageActivity = Event.None;
+    override createProxy<T extends object>(path: unknown, target?: unknown): RpcProxy<T> {
+        console.debug(`[Frontend-Only Fallback] Created proxy connection for ${path}`);
+        const factory = target instanceof RpcProxyFactory ? target : new RpcProxyFactory<T>(target);
+        return factory.createProxy();
+    }
+    override listen(path: string, handler: ServiceConnectionProvider.ConnectionHandler, reconnect: boolean): void {
+        console.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
+    }
+}

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

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// Copyright (C) 2023 EclipseSource 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 { ContainerModule } from 'inversify';
+import { WebSocketConnectionSource } from '../../browser/messaging/ws-connection-source';
+import { FrontendOnlyConnectionSource, FrontendOnlyServiceConnectionProvider } from './frontend-only-service-connection-provider';
+import { ConnectionSource } from '../../browser/messaging/connection-source';
+import { LocalConnectionProvider, RemoteConnectionProvider } from '../../browser/messaging/service-connection-provider';
+
+// is loaded directly after the regular message frontend module
+export const messagingFrontendOnlyModule = new ContainerModule((bind, unbind, isBound, rebind) => {
+    unbind(WebSocketConnectionSource);
+    bind(FrontendOnlyConnectionSource).toSelf().inSingletonScope();
+    if (isBound(ConnectionSource)) {
+        rebind(ConnectionSource).toService(FrontendOnlyConnectionSource);
+    } else {
+        bind(ConnectionSource).toService(FrontendOnlyConnectionSource);
+    }
+    bind(FrontendOnlyServiceConnectionProvider).toSelf().inSingletonScope();
+    if (isBound(LocalConnectionProvider)) {
+        rebind(LocalConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    } else {
+        bind(LocalConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    }
+    if (isBound(RemoteConnectionProvider)) {
+        rebind(RemoteConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    } else {
+        bind(RemoteConnectionProvider).toService(FrontendOnlyServiceConnectionProvider);
+    }
+});

package/src/browser-only/preload/frontend-only-preload-module.ts

@@ -0,0 +1,49 @@
+// *****************************************************************************
+// Copyright (C) 2023 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 { ContainerModule } from 'inversify';
+import { LocalizationServer } from '../../common/i18n/localization-server';
+import { OS, OSBackendProvider } from '../../common/os';
+import { Localization } from '../../common/i18n/localization';
+
+// loaded after regular preload module
+export default new ContainerModule((bind, unbind, isBound, rebind) => {
+    const frontendOnlyLocalizationServer: LocalizationServer = {
+        loadLocalization: async (languageId: string): Promise<Localization> => ({ translations: {}, languageId })
+    };
+    if (isBound(LocalizationServer)) {
+        rebind(LocalizationServer).toConstantValue(frontendOnlyLocalizationServer);
+    } else {
+        bind(LocalizationServer).toConstantValue(frontendOnlyLocalizationServer);
+    }
+
+    const frontendOnlyOSBackendProvider: OSBackendProvider = {
+        getBackendOS: async (): Promise<OS.Type> => {
+            if (window.navigator.platform.startsWith('Win')) {
+                return OS.Type.Windows;
+            } else if (window.navigator.platform.startsWith('Mac')) {
+                return OS.Type.OSX;
+            } else {
+                return OS.Type.Linux;
+            }
+        }
+    };
+    if (isBound(OSBackendProvider)) {
+        rebind(OSBackendProvider).toConstantValue(frontendOnlyOSBackendProvider);
+    } else {
+        bind(OSBackendProvider).toConstantValue(frontendOnlyOSBackendProvider);
+    }
+});

package/src/common/application-protocol.ts

@@ -23,6 +23,7 @@ export const ApplicationServer = Symbol('ApplicationServer');
 export interface ApplicationServer {
     getExtensionsInfos(): Promise<ExtensionInfo[]>;
     getApplicationInfo(): Promise<ApplicationInfo | undefined>;
+    getApplicationRoot(): Promise<string>;
     /**
      * @deprecated since 1.25.0. Use `OS.backend.type()` instead.
      */

package/src/common/disposable.ts

@@ -133,3 +133,28 @@ export function disposableTimeout(...args: Parameters<typeof setTimeout>): Dispo
     const handle = setTimeout(...args);
     return { dispose: () => clearTimeout(handle) };
 }
+
+/**
+ * Wrapper for a {@link Disposable} that is not available immediately.
+ */
+export class DisposableWrapper implements Disposable {
+
+    private disposed = false;
+    private disposable: Disposable | undefined = undefined;
+
+    set(disposable: Disposable): void {
+        if (this.disposed) {
+            disposable.dispose();
+        } else {
+            this.disposable = disposable;
+        }
+    }
+
+    dispose(): void {
+        this.disposed = true;
+        if (this.disposable) {
+            this.disposable.dispose();
+            this.disposable = undefined;
+        }
+    }
+}

package/src/{node → common}/file-uri.ts

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import { URI as Uri } from 'vscode-uri';
-import URI from '../common/uri';
-import { isWindows } from '../common/os';
+import URI from './uri';
+import { isWindows } from './os';
 
 export namespace FileUri {
 

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