@theia/core 1.45.1 → 1.46.0-next.106

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

@@ -99,21 +99,41 @@ export interface TreeModel extends Tree, TreeSelectionService, TreeExpansionServ
      */
     navigateBackward(): Promise<void>;
 
+    /**
+     * Selects the previous tree node, regardless of its selection or visibility state.
+     */
+    selectPrev(): void;
+
     /**
      * Selects the previous node relatively to the currently selected one. This method takes the expansion state of the tree into consideration.
      */
     selectPrevNode(type?: TreeSelection.SelectionType): void;
 
+    /**
+     * Returns the previous tree node, regardless of its selection or visibility state.
+     */
+    getPrevNode(node?: TreeNode): TreeNode | undefined;
+
     /**
      * Returns the previous selectable tree node.
      */
     getPrevSelectableNode(node?: TreeNode): SelectableTreeNode | undefined;
 
+    /**
+     * Selects the next tree node, regardless of its selection or visibility state.
+     */
+    selectNext(): void;
+
     /**
      * Selects the next node relatively to the currently selected one. This method takes the expansion state of the tree into consideration.
      */
     selectNextNode(type?: TreeSelection.SelectionType): void;
 
+    /**
+     * Returns the next tree node, regardless of its selection or visibility state.
+     */
+    getNextNode(node?: TreeNode): TreeNode | undefined;
+
     /**
      * Returns the next selectable tree node.
      */
@@ -294,6 +314,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    selectPrev(): void {
+        const node = this.getPrevNode();
+        this.selectNodeIfSelectable(node);
+    }
+
     selectPrevNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
         const node = this.getPrevSelectableNode();
         if (node) {
@@ -301,6 +326,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    getPrevNode(node: TreeNode | undefined = this.getFocusedNode()): TreeNode | undefined {
+        const iterator = this.createBackwardTreeIterator(node);
+        return iterator && this.doGetNode(iterator);
+    }
+
     getPrevSelectableNode(node: TreeNode | undefined = this.getFocusedNode()): SelectableTreeNode | undefined {
         if (!node) {
             return this.getNextSelectableNode(this.root);
@@ -309,6 +339,11 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
+    selectNext(): void {
+        const node = this.getNextNode();
+        this.selectNodeIfSelectable(node);
+    }
+
     selectNextNode(type: TreeSelection.SelectionType = TreeSelection.SelectionType.DEFAULT): void {
         const node = this.getNextSelectableNode();
         if (node) {
@@ -316,11 +351,28 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         }
     }
 
+    getNextNode(node: TreeNode | undefined = this.getFocusedNode()): TreeNode | undefined {
+        const iterator = this.createTreeIterator(node);
+        return iterator && this.doGetNode(iterator);
+    }
+
     getNextSelectableNode(node: TreeNode | undefined = this.getFocusedNode() ?? this.root): SelectableTreeNode | undefined {
         const iterator = this.createIterator(node);
         return iterator && this.doGetNextNode(iterator, this.isVisibleSelectableNode.bind(this));
     }
 
+    protected selectNodeIfSelectable(node: TreeNode | undefined): void {
+        if (SelectableTreeNode.is(node)) {
+            this.addSelection(node);
+        }
+    }
+
+    protected doGetNode(iterator: TreeIterator): TreeNode | undefined {
+        iterator.next();
+        const result = iterator.next();
+        return result.done ? undefined : result.value;
+    }
+
     protected doGetNextNode<T extends TreeNode>(iterator: TreeIterator, criterion: (node: TreeNode) => node is T): T | undefined {
         // Skip the first item. // TODO: clean this up, and skip the first item in a different way without loading everything.
         iterator.next();
@@ -338,6 +390,17 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return SelectableTreeNode.isVisible(node);
     }
 
+    protected createBackwardTreeIterator(node: TreeNode | undefined): TreeIterator | undefined {
+        const { filteredNodes } = this.treeSearch;
+        if (filteredNodes.length === 0) {
+            return node ? new BottomUpTreeIterator(node!, { pruneCollapsed: false }) : undefined;
+        }
+        if (node && filteredNodes.indexOf(node) === -1) {
+            return undefined;
+        }
+        return Iterators.cycle(filteredNodes.slice().reverse(), node);
+    }
+
     protected createBackwardIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {
@@ -349,6 +412,17 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return Iterators.cycle(filteredNodes.slice().reverse(), node);
     }
 
+    protected createTreeIterator(node: TreeNode | undefined): TreeIterator | undefined {
+        const { filteredNodes } = this.treeSearch;
+        if (filteredNodes.length === 0) {
+            return node && new TopDownTreeIterator(node, { pruneCollapsed: false });
+        }
+        if (node && filteredNodes.indexOf(node) === -1) {
+            return undefined;
+        }
+        return Iterators.cycle(filteredNodes, node);
+    }
+
     protected createIterator(node: TreeNode | undefined): TreeIterator | undefined {
         const { filteredNodes } = this.treeSearch;
         if (filteredNodes.length === 0) {

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-selectable.spec.ts

@@ -0,0 +1,152 @@
+// *****************************************************************************
+// Copyright (C) 2018 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 { TreeNode } from './tree';
+import { TreeModel } from './tree-model';
+import { notEmpty } from '../../common/objects';
+import { expect } from 'chai';
+import { createTreeTestContainer } from './test/tree-test-container';
+import { SelectableTreeNode } from './tree-selection';
+import { MockSelectableTreeModel } from './test/mock-selectable-tree-model';
+import { ExpandableTreeNode } from './tree-expansion';
+
+describe('Selectable Tree', () => {
+    let model: TreeModel;
+    function assertNodeRetrieval(method: () => TreeNode | undefined, sequence: string[]): void {
+        for (const expectedNodeId of sequence) {
+            const actualNode = method();
+            const expectedNode = retrieveNode<SelectableTreeNode>(expectedNodeId);
+            expect(actualNode?.id).to.be.equal(expectedNode.id);
+            model.addSelection(expectedNode);
+        }
+    }
+    function assertNodeSelection(method: () => void, sequence: string[]): void {
+        for (const expectedNodeId of sequence) {
+            method();
+            const node = retrieveNode<SelectableTreeNode>(expectedNodeId);
+            expect(node.selected).to.be.true;
+        }
+    }
+    describe('Get and Set Next Nodes Methods', () => {
+        const uncollapsedSelectionOrder = ['1.1', '1.1.1', '1.1.2', '1.2', '1.2.1', '1.2.1.1', '1.2.1.2', '1.2.2', '1.2.3', '1.3'];
+        const collapsedSelectionOrder = ['1.1', '1.2', '1.2.1', '1.2.2', '1.2.3', '1.3'];
+        beforeEach(() => {
+            model = createTreeModel();
+            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
+            model.addSelection(retrieveNode<SelectableTreeNode>('1'));
+
+        });
+        it('`getNextNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextSelectableNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getNextSelectableNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getNextSelectableNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getNextSelectableNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+        it('`selectNext()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNext()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectNext.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNextNode()` should select each node in sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectNextNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectNextNode()` should select each node in sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectNextNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+    });
+
+    describe('Get and Set Previous Nodes Methods', () => {
+        const uncollapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1.2', '1.2.1.1', '1.2.1', '1.2', '1.1.2', '1.1.1', '1.1'];
+        const collapsedSelectionOrder = ['1.2.3', '1.2.2', '1.2.1', '1.2', '1.1'];
+        beforeEach(() => {
+            model = createTreeModel();
+            model.root = MockSelectableTreeModel.HIERARCHICAL_MOCK_ROOT();
+            model.addSelection(retrieveNode<SelectableTreeNode>('1.3'));
+        });
+        it('`getPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevSelectableNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`getPrevSelectableNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeRetrieval(model.getPrevSelectableNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrev()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrev()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectPrev.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrevNode()` should select each node in reverse sequence (uncollapsed)', done => {
+            assertNodeSelection(model.selectPrevNode.bind(model), uncollapsedSelectionOrder);
+            done();
+        });
+        it('`selectPrevNode()` should select each node in reverse sequence (collapsed)', done => {
+            collapseNode('1.1', '1.2.1');
+            assertNodeSelection(model.selectPrevNode.bind(model), collapsedSelectionOrder);
+            done();
+        });
+    });
+
+    const findNode = (id: string) => model.getNode(id);
+    function createTreeModel(): TreeModel {
+        const container = createTreeTestContainer();
+        return container.get(TreeModel);
+    }
+    function retrieveNode<T extends TreeNode>(id: string): Readonly<T> {
+        const readonlyNode: Readonly<T> = model.getNode(id) as T;
+        return readonlyNode;
+    }
+    function collapseNode(...ids: string[]): void {
+        ids.map(findNode).filter(notEmpty).filter(ExpandableTreeNode.is).forEach(node => {
+            model.collapseNode(node);
+            expect(node).to.have.property('expanded', false);
+        });
+    }
+
+});

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/widgets/widget.ts

@@ -381,12 +381,20 @@ export function pin(title: Title<Widget>): void {
     }
 }
 
+export function isLocked(title: Title<Widget>): boolean {
+    return title.className.includes(LOCKED_CLASS);
+}
+
 export function lock(title: Title<Widget>): void {
     if (!title.className.includes(LOCKED_CLASS)) {
         title.className += ` ${LOCKED_CLASS}`;
     }
 }
 
+export function unlock(title: Title<Widget>): void {
+    title.className = title.className.replace(LOCKED_CLASS, '').trim();
+}
+
 export function togglePinned(title?: Title<Widget>): void {
     if (title) {
         if (isPinned(title)) {

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

@@ -18,6 +18,11 @@ import { StopReason } from '../../common/frontend-application-state';
 import { Event } from '../../common/event';
 import { NewWindowOptions, WindowSearchParams } from '../../common/window';
 
+export interface WindowReloadOptions {
+    search?: WindowSearchParams,
+    hash?: string
+}
+
 /**
  * Service for opening new browser windows.
  */
@@ -35,7 +40,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(params?: WindowSearchParams): void;
+    openNewDefaultWindow(params?: WindowReloadOptions): 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 +69,5 @@ export interface WindowService {
     /**
      * Reloads the window according to platform.
      */
-    reload(params?: WindowSearchParams): void;
+    reload(params?: WindowReloadOptions): void;
 }

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