@theia/core 1.77.0-next.47 → 1.77.0-next.56

package/src/browser/quick-input/quick-command-service.spec.ts

@@ -0,0 +1,159 @@
+// *****************************************************************************
+// Copyright (C) 2026 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 { enableJSDOM } from '../test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import * as chai from 'chai';
+import { Container } from 'inversify';
+import { CancellationToken, CommandRegistry, Emitter } from '../../common';
+import { CorePreferences } from '../../common/core-preferences';
+import { ContextKeyService, ContextKeyServiceDummyImpl } from '../context-key-service';
+import { KeybindingRegistry } from '../keybinding';
+import { QuickAccessRegistry } from './quick-access';
+import { QuickCommandService } from './quick-command-service';
+import { QuickInputService, QuickPickItem } from './quick-input-service';
+
+disableJSDOM();
+
+const expect = chai.expect;
+
+class RecordingContextKeyService extends ContextKeyServiceDummyImpl {
+    activeContext: unknown;
+
+    override withContext<T>(context: unknown, callback: () => T): T {
+        const previous = this.activeContext;
+        this.activeContext = context;
+        try {
+            return callback();
+        } finally {
+            this.activeContext = previous;
+        }
+    }
+}
+
+describe('quick-command-service', () => {
+
+    let editor: HTMLElement;
+    let quickInput: HTMLInputElement;
+    let contextKeyService: RecordingContextKeyService;
+    let commandRegistry: CommandRegistry;
+    let onHideEmitter: Emitter<void>;
+    let quickInputService: { previousFocusElement?: HTMLElement, onHide: Emitter<void>['event'] };
+    let service: QuickCommandService;
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    beforeEach(() => {
+        editor = document.createElement('div');
+        editor.tabIndex = 0;
+        quickInput = document.createElement('input');
+        document.body.append(editor, quickInput);
+        // Focus has moved to the quick input, as it does while the palette is open.
+        quickInput.focus();
+
+        contextKeyService = new RecordingContextKeyService();
+        commandRegistry = new CommandRegistry({ getContributions: () => [] });
+        onHideEmitter = new Emitter<void>();
+        quickInputService = { previousFocusElement: editor, onHide: onHideEmitter.event };
+
+        const container = new Container();
+        container.bind(ContextKeyService).toConstantValue(contextKeyService);
+        container.bind(CommandRegistry).toConstantValue(commandRegistry);
+        container.bind(CorePreferences).toConstantValue(<CorePreferences>{ 'workbench.commandPalette.history': 50 });
+        container.bind(QuickAccessRegistry).toConstantValue(<QuickAccessRegistry>{});
+        container.bind(KeybindingRegistry).toConstantValue(<KeybindingRegistry><unknown>{ getKeybindingsForCommand: () => [] });
+        container.bind(QuickInputService).toConstantValue(<QuickInputService><unknown>quickInputService);
+        container.bind(QuickCommandService).toSelf();
+        service = container.get(QuickCommandService);
+    });
+
+    afterEach(() => {
+        editor.remove();
+        quickInput.remove();
+        onHideEmitter.dispose();
+    });
+
+    function inEditorContext(): boolean {
+        return contextKeyService.activeContext === editor;
+    }
+
+    function picks(): QuickPickItem[] {
+        return service.getPicks('', CancellationToken.None).filter((pick): pick is QuickPickItem => pick.type !== 'separator');
+    }
+
+    it('evaluates command enablement against the element focused before the quick input opened', () => {
+        commandRegistry.registerCommand({ id: 'test.editorOnly', label: 'Editor Only' }, { execute: () => { }, isEnabled: inEditorContext });
+
+        expect(picks().map(pick => pick.label)).to.deep.equal(['Editor Only']);
+    });
+
+    it('evaluates item state against the element focused before the quick input opened', () => {
+        commandRegistry.registerCommand({ id: 'test.toggle', label: 'Toggle' }, { execute: () => { }, isEnabled: inEditorContext, isToggled: inEditorContext });
+
+        const [item] = picks();
+        expect(item.alwaysShow).to.be.true;
+        expect(item.iconClasses).to.not.be.undefined;
+    });
+
+    it('evaluates pushed command contexts against the element focused before the quick input opened', () => {
+        contextKeyService.match = () => inEditorContext();
+        commandRegistry.registerCommand({ id: 'test.when', label: 'When' }, { execute: () => { } });
+        service.pushCommandContext('test.when', 'editorFocus');
+
+        expect(picks().map(pick => pick.label)).to.deep.equal(['When']);
+    });
+
+    it('restores focus to the element focused before the quick input opened on execute', () => {
+        commandRegistry.registerCommand({ id: 'test.command', label: 'Command' }, { execute: () => { } });
+
+        picks()[0].execute!();
+
+        expect(document.activeElement).to.equal(editor);
+    });
+
+    it('falls back to the active element when items are created without a reset', () => {
+        commandRegistry.registerCommand({ id: 'test.command', label: 'Command' }, { execute: () => { } });
+        const item = service.toItem({ id: 'test.command', label: 'Command' });
+        editor.focus();
+
+        item.execute!();
+
+        expect(document.activeElement).to.equal(quickInput);
+    });
+
+    it('forgets the context element when the quick input is hidden', () => {
+        commandRegistry.registerCommand({ id: 'test.command', label: 'Command' }, { execute: () => { } });
+        service.reset();
+        onHideEmitter.fire();
+
+        const item = service.toItem({ id: 'test.command', label: 'Command' });
+        editor.focus();
+        item.execute!();
+
+        expect(document.activeElement).to.equal(quickInput);
+    });
+
+});

package/src/browser/quick-input/quick-command-service.ts

@@ -14,13 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable } from 'inversify';
+import { inject, injectable, optional, postConstruct } from 'inversify';
 import { KeybindingRegistry } from '../keybinding';
 import { Disposable, Command, CommandRegistry, CancellationToken, nls } from '../../common';
 import { ContextKeyService } from '../context-key-service';
 import { CorePreferences } from '../../common/core-preferences';
 import { QuickAccessContribution, QuickAccessProvider, QuickAccessRegistry } from './quick-access';
-import { filterItems, QuickPickItem, QuickPicks } from './quick-input-service';
+import { filterItems, QuickInputService, QuickPickItem, QuickPicks } from './quick-input-service';
 import { KeySequence } from '../keys';
 import { codiconArray } from '../widgets';
 
@@ -56,6 +56,9 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     @inject(KeybindingRegistry)
     protected readonly keybindingRegistry: KeybindingRegistry;
 
+    @inject(QuickInputService) @optional()
+    protected readonly quickInputService: QuickInputService | undefined;
+
     // The list of exempted commands not to be displayed in the recently used list.
     readonly exemptedCommands: Command[] = [
         CLEAR_COMMAND_HISTORY,
@@ -64,6 +67,17 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     private recentItems: QuickPickItem[] = [];
     private otherItems: QuickPickItem[] = [];
 
+    /**
+     * The element that was focused when the quick input was opened.
+     * Commands are evaluated against its context, since focus moves to the quick input while the palette is open.
+     */
+    protected commandContextElement: HTMLElement | undefined;
+
+    @postConstruct()
+    protected init(): void {
+        this.quickInputService?.onHide(() => this.commandContextElement = undefined);
+    }
+
     registerQuickAccessProvider(): void {
         this.quickAccessRegistry.registerQuickAccessProvider({
             getInstance: () => this,
@@ -74,11 +88,12 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     }
 
     reset(): void {
-        const { recent, other } = this.getCommands();
-        this.recentItems = [];
-        this.otherItems = [];
-        this.recentItems.push(...recent.map(command => this.toItem(command)));
-        this.otherItems.push(...other.map(command => this.toItem(command)));
+        this.updateCommandContextElement();
+        this.withCommandContext(() => {
+            const { recent, other } = this.getCommands();
+            this.recentItems = recent.map(command => this.toItem(command));
+            this.otherItems = other.map(command => this.toItem(command));
+        });
     }
 
     getPicks(filter: string, token: CancellationToken): QuickPicks {
@@ -105,7 +120,8 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
     toItem(command: Command): QuickPickItem {
         const label = (command.category) ? `${command.category}: ` + command.label! : command.label!;
         const iconClasses = this.getItemIconClasses(command);
-        const activeElement = window.document.activeElement as HTMLElement;
+        const activeElement = window.document.activeElement;
+        const commandContextElement = this.commandContextElement ?? (activeElement instanceof HTMLElement ? activeElement : undefined);
 
         const originalLabel = command.originalLabel || command.label!;
         const originalCategory = command.originalCategory || command.category;
@@ -121,13 +137,24 @@ export class QuickCommandService implements QuickAccessContribution, QuickAccess
             alwaysShow: !!this.commandRegistry.getActiveHandler(command.id),
             keySequence: this.getKeybinding(command),
             execute: () => {
-                activeElement.focus({ preventScroll: true });
+                commandContextElement?.focus({ preventScroll: true });
                 this.commandRegistry.executeCommand(command.id);
                 this.commandRegistry.addRecentCommand(command);
             }
         };
     }
 
+    protected updateCommandContextElement(): void {
+        // When the palette is opened directly, the picks are computed before the quick input is shown and focused.
+        const element = this.quickInputService?.previousFocusElement ?? window.document.activeElement;
+        this.commandContextElement = element instanceof HTMLElement ? element : undefined;
+    }
+
+    protected withCommandContext<T>(callback: () => T): T {
+        const element = this.commandContextElement;
+        return element?.isConnected ? this.contextKeyService.withContext(element, callback) : callback();
+    }
+
     private getKeybinding(command: Command): KeySequence | undefined {
         const keybindings = this.keybindingRegistry.getKeybindingsForCommand(command.id);
         if (!keybindings || keybindings.length === 0) {

package/src/browser/quick-input/quick-help-service.ts

@@ -60,7 +60,7 @@ export class QuickHelpService implements QuickAccessProvider, QuickAccessContrib
 
             for (const helpEntry of provider.helpEntries) {
                 const prefix = helpEntry.prefix || provider.prefix;
-                const label = prefix || '\u2026' /* ... */;
+                const label = prefix || '\u2026'; // ...
 
                 (helpEntry.needsEditor ? editorProviders : globalProviders).push({
                     label,

package/src/browser/tree/tree-container.spec.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as assert from 'assert';
+import assert from 'assert';
 import { Container } from 'inversify';
 import { createTreeContainer, isTreeServices } from './tree-container';
 import { TreeSearch } from './tree-search';

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

@@ -47,7 +47,7 @@ export abstract class AbstractTreeIterator implements TreeIterator, Iterable<Tre
         this.delegate = this.iterator(this.root);
     }
 
-    // tslint:disable-next-line:typedef
+    // eslint-disable-next-line @theia/explicit-return-type
     [Symbol.iterator]() {
         return this.delegate;
     }

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

@@ -263,12 +263,12 @@ export class TreeModelImpl implements TreeModel, SelectionProvider<ReadonlyArray
         return this.tree.refresh();
     }
 
-    // tslint:disable-next-line:typedef
+    // eslint-disable-next-line @theia/explicit-return-type
     get selectedNodes() {
         return this.selectionService.selectedNodes;
     }
 
-    // tslint:disable-next-line:typedef
+    // eslint-disable-next-line @theia/explicit-return-type
     get onSelectionChanged() {
         return this.selectionService.onSelectionChanged;
     }

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

@@ -120,7 +120,7 @@ export interface TreeProps {
     /**
      * Props that are forwarded to the virtuoso list rendered. Defaults to `{}`.
      */
-    readonly viewProps?: VirtuosoProps<unknown, unknown>;
+    readonly viewProps?: Omit<VirtuosoProps<unknown, unknown>, 'width' | 'height' | 'rows'>;
 }
 
 /**
@@ -1602,7 +1602,7 @@ export namespace TreeWidget {
     /**
      * Representation of the tree view properties.
      */
-    export interface ViewProps extends VirtuosoProps<unknown, unknown> {
+    export interface ViewProps extends Omit<VirtuosoProps<unknown, unknown>, 'width' | 'height' | 'rows'> {
         /**
          * The width property.
          */

package/src/common/cancellation.ts

@@ -128,7 +128,7 @@ export class CancellationTokenSource {
             // before someone asks for the token
             this._token = CancellationToken.Cancelled;
         } else if (this._token !== CancellationToken.Cancelled) {
-            (<MutableToken>this._token).cancel();
+            (this._token as MutableToken).cancel();
         }
     }
 

package/src/common/disposable.spec.ts

@@ -16,7 +16,7 @@
 
 import { expect, spy, use } from 'chai';
 import { DisposableCollection, Disposable } from './disposable';
-import * as spies from 'chai-spies';
+import spies from 'chai-spies';
 
 use(spies);
 

package/src/common/event.ts

@@ -166,8 +166,7 @@ class CallbackList implements Iterable<Callback> {
         }
     }
 
-    // tslint:disable-next-line:typedef
-    public [Symbol.iterator]() {
+    public [Symbol.iterator](): IterableIterator<Callback> {
         if (!this._callbacks) {
             return [][Symbol.iterator]();
         }

package/src/common/glob.ts

@@ -127,11 +127,8 @@ function parseRegExp(pattern: string): string {
     // Special case where we only have globstars
     if (segments.every(s => s === GLOBSTAR)) {
         regEx = '.*';
-    }
-
-    // Build regex over segments
-    // tslint:disable-next-line:one-line
-    else {
+    } else {
+        // Build regex over segments
         let previousSegmentWasGlobStar = false;
         segments.forEach((segment, index) => {
 
@@ -171,24 +168,15 @@ function parseRegExp(pattern: string): string {
                     // range operator
                     if (char === '-') {
                         res = char;
-                    }
-
-                    // negation operator (only valid on first index in bracket)
-                    // tslint:disable-next-line:one-line
-                    else if ((char === '^' || char === '!') && !bracketVal) {
+                    } else if ((char === '^' || char === '!') && !bracketVal) {
+                        // negation operator (only valid on first index in bracket)
                         res = '^';
-                    }
-
-                    // glob split matching is not allowed within character ranges
-                    // see http://man7.org/linux/man-pages/man7/glob.7.html
-                    // tslint:disable-next-line:one-line
-                    else if (char === GLOB_SPLIT) {
+                    } else if (char === GLOB_SPLIT) {
+                        // glob split matching is not allowed within character ranges
+                        // see http://man7.org/linux/man-pages/man7/glob.7.html
                         res = '';
-                    }
-
-                    // anything else gets escaped
-                    // tslint:disable-next-line:one-line
-                    else {
+                    } else {
+                        // anything else gets escaped
                         res = strings.escapeRegExpCharacters(char);
                     }
 
@@ -270,7 +258,7 @@ export type ParsedPattern = (path: string, basename?: string) => boolean;
 
 // The ParsedExpression returns a Promise iff hasSibling returns a Promise.
 // eslint-disable-next-line max-len
-export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>) => string | Promise<string> /* the matching pattern */;
+export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>) => string | Promise<string>; // the matching pattern
 
 export interface IGlobOptions {
     /**
@@ -341,11 +329,8 @@ function parsePattern(arg1: string | IRelativePattern, options: IGlobOptions): P
         parsedPattern = trivia4and5(match[1].substring(1), pattern, true);
     } else if (match = T5.exec(trimForExclusions(pattern, options))!) { // common pattern: something/else just need equals check
         parsedPattern = trivia4and5(match[1], pattern, false);
-    }
-
-    // Otherwise convert to pattern
-    // tslint:disable-next-line:one-line
-    else {
+    } else {
+        // Otherwise convert to pattern
         parsedPattern = toRegExp(pattern);
     }
 
@@ -461,7 +446,7 @@ function toRegExp(pattern: string): ParsedStringPattern {
  * - character ranges (using [...])
  */
 export function match(pattern: string | IRelativePattern, path: string): boolean;
-export function match(expression: IExpression, path: string, hasSibling?: (name: string) => boolean): string /* the matching pattern */;
+export function match(expression: IExpression, path: string, hasSibling?: (name: string) => boolean): string; // the matching pattern
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function match(arg1: string | IExpression | IRelativePattern, path: string, hasSibling?: (name: string) => boolean): any {
     if (!arg1 || !path) {
@@ -593,7 +578,6 @@ function parsedExpression(expression: IExpression, options: IGlobOptions): Parse
         // eslint-disable-next-line @typescript-eslint/no-shadow
         const resultExpression: ParsedStringPattern = function (path: string, basename: string): string | Promise<string> {
             // eslint-disable-next-line @typescript-eslint/no-shadow
-            // tslint:disable-next-line:one-variable-per-declaration
             for (let i = 0, n = parsedPatterns.length; i < n; i++) {
                 // Pattern matches path
                 const result = (<ParsedStringPattern>parsedPatterns[i])(path, basename);
@@ -707,7 +691,6 @@ function aggregateBasenameMatches(parsedPatterns: (ParsedStringPattern | ParsedE
     let patterns: string[];
     if (result) {
         patterns = [];
-        // tslint:disable-next-line:one-variable-per-declaration
         for (let i = 0, n = basenames.length; i < n; i++) {
             patterns.push(result);
         }

package/src/common/json-schema.ts

@@ -26,7 +26,7 @@ export type JsonType = 'string' | 'array' | 'number' | 'integer' | 'object' | 'b
 // copied from https://github.com/Microsoft/vscode/blob/d4edb9abcc261846cabee6702715fe2914ae42cb/src/vs/base/common/jsonSchema.ts
 
 // Keep tab indent for easier comparison with the original file.
-/* eslint-disable @typescript-eslint/indent */
+/* eslint-disable @stylistic/indent */
 
 /**
  * extended JSON schema

package/src/common/keys.ts

@@ -373,7 +373,7 @@ export namespace KeyCode {
             }
         }
 
-        // tslint:disable-next-line: deprecation
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
         const keyCode = event.keyCode;
         if (keyCode) {
             const key = Key.getKey(keyCode);

package/src/common/message-rpc/channel.spec.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { assert, expect, spy, use } from 'chai';
-import * as spies from 'chai-spies';
+import spies from 'chai-spies';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from './uint8-array-message-buffer';
 import { ChannelMultiplexer, ForwardingChannel, MessageProvider } from './channel';
 import { RpcProtocol } from './rpc-protocol';

package/src/common/messaging/proxy-factory.ts

@@ -333,7 +333,7 @@ export class JsonRpcProxyFactory<T extends object> extends RpcProxyFactory<T> {
 
 }
 
-// eslint-disable-next-line deprecation/deprecation
+// eslint-disable-next-line @typescript-eslint/no-deprecated
 decorate(injectable(), JsonRpcProxyFactory);
-// eslint-disable-next-line deprecation/deprecation
+// eslint-disable-next-line @typescript-eslint/no-deprecated
 decorate(unmanaged(), JsonRpcProxyFactory, 0);

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

@@ -282,6 +282,11 @@ export interface QuickInputService {
     readonly backButton: QuickInputButton;
     readonly onShow: Event<void>;
     readonly onHide: Event<void>;
+    /**
+     * The element that had focus when the quick input was shown, while the quick input is showing.
+     * Items whose state depends on context keys should be evaluated against this element rather than the quick input itself.
+     */
+    readonly previousFocusElement?: HTMLElement;
     open(filter: string): void;
     createInputBox(): InputBox;
     input(options?: InputOptions, token?: CancellationToken): Promise<string | undefined>;

package/src/common/stream.ts

@@ -22,7 +22,8 @@
 
 /* eslint-disable max-len */
 /* eslint-disable no-null/no-null */
-/* eslint-disable @typescript-eslint/tslint/config */
+/* eslint-disable @stylistic/brace-style */
+/* eslint-disable @theia/explicit-return-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { DisposableCollection, Disposable } from './disposable';
@@ -730,7 +731,7 @@ export function fileToStream(file: File): ReadableStream<BinaryBuffer> {
         try {
             while (true) {
                 const { value, done } = await reader.read();
-                if (done) {break;}
+                if (done) { break; }
 
                 if (value?.byteLength) {
                     await ws.write(BinaryBuffer.wrap(value));
@@ -740,7 +741,7 @@ export function fileToStream(file: File): ReadableStream<BinaryBuffer> {
         } catch (e: unknown) {
             try {
                 await reader.cancel();
-            } catch {}
+            } catch { }
 
             ws.error(e instanceof Error ? e : new Error(String(e)));
         }

package/src/common/strings.ts

@@ -76,11 +76,8 @@ function doEqualsIgnoreCase(a: string, b: string, stopAt = a.length): boolean {
             if (diff !== 0 && diff !== 32) {
                 return false;
             }
-        }
-
-        // Any other charcode
-        // tslint:disable-next-line:one-line
-        else {
+        } else {
+            // Any other charcode
             if (String.fromCharCode(codeA).toLowerCase() !== String.fromCharCode(codeB).toLowerCase()) {
                 return false;
             }

package/src/common/ternary-search-tree.ts

@@ -21,7 +21,7 @@
 // based on https://github.com/microsoft/vscode/blob/04c36be045a94fee58e5f8992d3e3fd980294a84/src/vs/base/common/map.ts#L251
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/tslint/config */
+/* eslint-disable @theia/explicit-return-type */
 
 import URI from './uri';
 import { CharCode } from './char-code';

package/src/common/uri-command-handler.ts

@@ -133,7 +133,7 @@ export namespace UriAwareCommandHandler {
      * @returns a command handler for mono-select contexts that expects a `URI` as the first parameter of its methods.
      */
     export function MonoSelect(selectionService: SelectionService, handler: UriCommandHandler<URI>): UriAwareCommandHandler<URI> {
-        /* eslint-disable-next-line deprecation/deprecation*/ // Safe to use when the generic and the options agree.
+        /* eslint-disable-next-line @typescript-eslint/no-deprecated */ // Safe to use when the generic and the options agree.
         return new UriAwareCommandHandler<URI>(selectionService, handler, { multi: false });
     }
 
@@ -141,7 +141,7 @@ export namespace UriAwareCommandHandler {
      * @returns a command handler for multi-select contexts that expects a `URI[]` as the first parameter of its methods.
      */
     export function MultiSelect(selectionService: SelectionService, handler: UriCommandHandler<URI[]>): UriAwareCommandHandler<URI[]> {
-        /* eslint-disable-next-line deprecation/deprecation*/ // Safe to use when the generic and the options agree.
+        /* eslint-disable-next-line @typescript-eslint/no-deprecated */ // Safe to use when the generic and the options agree.
         return new UriAwareCommandHandler<URI[]>(selectionService, handler, { multi: true });
     }
 }

package/src/node/backend-application.ts

@@ -18,7 +18,7 @@ import * as dns from 'dns';
 import * as path from 'path';
 import * as http from 'http';
 import * as https from 'https';
-import * as express from 'express';
+import express from 'express';
 import * as yargs from 'yargs';
 import * as fs from 'fs-extra';
 import { inject, named, injectable, type interfaces, postConstruct } from 'inversify';

package/src/node/cli.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as yargs from 'yargs';
+import yargs from 'yargs';
 import { inject, named, injectable } from 'inversify';
 import { ContributionProvider } from '../common/contribution-provider';
 import { MaybePromise } from '../common/types';

package/src/node/logger-cli-contribution.spec.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import * as yargs from 'yargs';
+import yargs from 'yargs';
 import * as temp from 'temp';
 import * as fs from 'fs';
 import { ContainerModule, Container } from 'inversify';