@theia/core 1.73.0-next.9 → 1.73.1

package/src/browser/tree/tree-view-welcome-widget.spec.ts

@@ -0,0 +1,82 @@
+// *****************************************************************************
+// 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';
+
+// The widget module transitively imports `@lumino/widgets`, which touches `document` at load time.
+const disableJSDOM = enableJSDOM();
+
+import { Container } from 'inversify';
+import { expect } from 'chai';
+import { ReactElement, ReactNode } from 'react';
+import { CommandService } from '../../common';
+import { LabelParser } from '../label-parser';
+import { codicon } from '../widgets';
+import { TreeViewWelcomeWidget } from './tree-view-welcome-widget';
+
+disableJSDOM();
+
+let labelParser: LabelParser;
+
+before(() => {
+    const container = new Container();
+    container.bind(LabelParser).toSelf().inSingletonScope();
+    container.bind(CommandService).toDynamicValue(() => ({
+        executeCommand<T>(): Promise<T | undefined> {
+            return Promise.resolve(undefined);
+        }
+    })).inSingletonScope();
+    labelParser = container.get(LabelParser);
+});
+
+describe('TreeViewWelcomeWidget#renderLabelWithIcons', () => {
+
+    type SpanElement = ReactElement<{ className?: string; children?: ReactNode }>;
+
+    // Exercise the protected helper without standing up the full TreeWidget DI graph.
+    function render(label: string): SpanElement[] {
+        const widget = Object.create(TreeViewWelcomeWidget.prototype) as {
+            labelParser: LabelParser;
+            renderLabelWithIcons(label: string): SpanElement[];
+        };
+        widget.labelParser = labelParser;
+        return widget.renderLabelWithIcons(label);
+    }
+
+    it('renders a leading $(codicon) as a codicon span and keeps the trailing text', () => {
+        const nodes = render('$(robot) Launch AI Agent');
+        expect(nodes).to.have.lengthOf(2);
+        expect(nodes[0].props.className).to.equal(codicon('robot'));
+        expect(nodes[0].props.children).to.be.undefined;
+        expect(nodes[1].props.className).to.be.undefined;
+        expect(nodes[1].props.children).to.equal(' Launch AI Agent');
+    });
+
+    it('renders a plain label as a single text span with no codicon', () => {
+        const nodes = render('Open Documentation');
+        expect(nodes).to.have.lengthOf(1);
+        expect(nodes[0].props.className).to.be.undefined;
+        expect(nodes[0].props.children).to.equal('Open Documentation');
+    });
+
+    it('renders multiple codicons interleaved with text', () => {
+        const nodes = render('$(package) Import $(gear) Library');
+        const iconNodes = nodes.filter(n => typeof n.props.className === 'string' && n.props.className.includes('codicon-'));
+        expect(iconNodes).to.have.lengthOf(2);
+        expect(iconNodes[0].props.className).to.equal(codicon('package'));
+        expect(iconNodes[1].props.className).to.equal(codicon('gear'));
+    });
+});

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

@@ -209,22 +209,14 @@ export class TreeViewWelcomeWidget extends TreeWidget {
                     className='theia-button theia-WelcomeViewButton'
                     disabled={!this.isEnabledClick(enablement)}
                     onClick={e => this.openLinkOrCommand(e, node.href)}>
-                    {node.label}
+                    {this.renderLabelWithIcons(node.label)}
                 </button>
             </div>
         );
     }
 
     protected renderTextNode(node: string, textKey: string | number): React.ReactNode {
-        return <span key={`text-${textKey}`}>
-            {this.labelParser.parse(node)
-                .map((segment, index) =>
-                    LabelIcon.is(segment)
-                        ? <span
-                            key={index}
-                            className={codicon(segment.name)}
-                        />
-                        : <span key={index}>{segment}</span>)}</span>;
+        return <span key={`text-${textKey}`}>{this.renderLabelWithIcons(node)}</span>;
     }
 
     protected renderLinkNode(node: ILink, linkKey: string | number, enablement: string | undefined): React.ReactNode {
@@ -233,11 +225,18 @@ export class TreeViewWelcomeWidget extends TreeWidget {
                 className={this.getLinkClassName(node.href, enablement)}
                 title={node.title || ''}
                 onClick={e => this.openLinkOrCommand(e, node.href)}>
-                {node.label}
+                {this.renderLabelWithIcons(node.label)}
             </a>
         );
     }
 
+    protected renderLabelWithIcons(label: string): React.ReactNode[] {
+        return this.labelParser.parse(label).map((segment, index) =>
+            LabelIcon.is(segment)
+                ? <span key={index} className={codicon(segment.name)} />
+                : <span key={index}>{segment}</span>);
+    }
+
     protected getLinkClassName(href: string, enablement: string | undefined): string {
         const classNames = ['theia-WelcomeViewCommandLink'];
         // Only command-backed links can be disabled. All other, https:, file: remain enabled

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

@@ -545,7 +545,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 return <this.ScrollingRowRenderer rows={rows} />;
             }
             return <TreeWidget.View
-                ref={view => this.view = (view || undefined)}
+                ref={view => { this.view = (view || undefined); }}
                 width={this.node.offsetWidth}
                 height={this.node.offsetHeight}
                 rows={rows}
@@ -1689,7 +1689,7 @@ export namespace TreeWidget {
         override render(): React.ReactNode {
             const { rows, width, height, scrollToRow, renderNodeRow, onScrollEmitter, ...other } = this.props;
             return <Virtuoso
-                ref={list => {
+                ref={(list: VirtuosoHandle | null) => {
                     this.list = (list || undefined);
                     this.scrollIntoViewIfNeeded();
                 }}

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

@@ -120,6 +120,36 @@ describe('Tree', () => {
 }`, node);
     });
 
+    it('removeChild - clears parent and sibling pointers on the removed node', () => {
+        const node = getNode();
+        const middle = node.children[1];
+        CompositeTreeNode.removeChild(node, middle);
+        expect(middle.parent).to.be.undefined;
+        expect(middle.previousSibling).to.be.undefined;
+        expect(middle.nextSibling).to.be.undefined;
+    });
+
+    it('removeChild - purges the detached subtree from the tree index when a tree is provided', () => {
+        const target = model.getNode('1.2');
+        expect(target).to.not.be.undefined;
+        const parent = target!.parent!;
+        expect(model.getNode('1.2.1')).to.not.be.undefined;
+        CompositeTreeNode.removeChild(parent, target!, model);
+        expect(model.getNode('1.2')).to.be.undefined;
+        expect(model.getNode('1.2.1')).to.be.undefined;
+    });
+
+    it('removeChild - leaves the index untouched when no tree is provided', () => {
+        const target = model.getNode('1.2')!;
+        const parent = target.parent!;
+        CompositeTreeNode.removeChild(parent, target);
+        // Until the caller explicitly purges, the orphan is still in the index.
+        expect(model.getNode('1.2')).to.equal(target);
+        // Explicit purge cleans it up.
+        model.removeNode(target);
+        expect(model.getNode('1.2')).to.be.undefined;
+    });
+
     let model: TreeModel;
     beforeEach(() => {
         model = createTreeModel();

package/src/browser/tree/tree.ts

@@ -14,13 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { injectable, inject, named } from 'inversify';
 import { Event, Emitter, WaitUntilEvent } from '../../common/event';
 import { Disposable, DisposableCollection } from '../../common/disposable';
 import { CancellationToken, CancellationTokenSource } from '../../common/cancellation';
 import { timeout } from '../../common/promise-util';
 import { isObject, Mutable } from '../../common';
 import { AccessibilityInformation } from '../../common/accessibility';
+import { ILogger } from '../../common/logger';
 
 export const Tree = Symbol('Tree');
 
@@ -78,6 +79,17 @@ export interface Tree extends Disposable {
     readonly onDidUpdate: Event<TreeNode[]>;
 
     markAsChecked(node: TreeNode, checked: boolean): void;
+
+    /**
+     * Remove the given node and all of its descendants from the tree's internal
+     * id-to-node index. Safe to call on already-detached subtrees.
+     *
+     * Callers that mutate the tree structure directly via
+     * {@link CompositeTreeNode.removeChild} should invoke this (or pass the tree
+     * to `removeChild`) to keep {@link getNode} and {@link validateNode} from
+     * returning orphaned nodes.
+     */
+    removeNode(node: TreeNode | undefined): void;
 }
 
 export interface TreeViewItemCheckboxInfo {
@@ -215,7 +227,17 @@ export namespace CompositeTreeNode {
         return parent;
     }
 
-    export function removeChild(parent: CompositeTreeNode, child: TreeNode): void {
+    /**
+     * Detach the given `child` from the `parent`.
+     *
+     * After this call, the child's `parent`, `previousSibling`, and
+     * `nextSibling` references are cleared, symmetric with `setParent`. If a
+     * `tree` is provided, the child and its descendants are also purged from
+     * the tree's id-to-node index so that {@link Tree.getNode} no longer
+     * returns the detached subtree. Otherwise the index entries persist and
+     * the caller is responsible for cleanup (e.g., via `tree.removeNode`).
+     */
+    export function removeChild(parent: CompositeTreeNode, child: TreeNode, tree?: Tree): void {
         const children = parent.children as TreeNode[];
         const index = children.findIndex(value => value.id === child.id);
         if (index === -1) {
@@ -229,6 +251,8 @@ export namespace CompositeTreeNode {
         if (nextSibling) {
             Object.assign(nextSibling, { previousSibling });
         }
+        Object.assign(child, { parent: undefined, previousSibling: undefined, nextSibling: undefined });
+        tree?.removeNode(child);
     }
 
     export function setParent(child: TreeNode, index: number, parent: CompositeTreeNode): void {
@@ -250,6 +274,9 @@ export namespace CompositeTreeNode {
 @injectable()
 export class TreeImpl implements Tree {
 
+    @inject(ILogger) @named('core:TreeImpl')
+    protected readonly logger: ILogger;
+
     protected _root: TreeNode | undefined;
     protected readonly onChangedEmitter = new Emitter<void>();
     protected readonly onNodeRefreshedEmitter = new Emitter<CompositeTreeNode & WaitUntilEvent>();
@@ -344,7 +371,7 @@ export class TreeImpl implements Tree {
     protected async setChildren(parent: CompositeTreeNode, children: TreeNode[]): Promise<CompositeTreeNode | undefined> {
         const root = this.getRootNode(parent);
         if (this.nodes[root.id] && this.nodes[root.id] !== root) {
-            console.error(`Child node '${parent.id}' does not belong to this '${root.id}' tree.`);
+            this.logger.error(`Child node '${parent.id}' does not belong to this '${root.id}' tree.`);
             return undefined;
         }
         this.removeNode(parent);
@@ -354,7 +381,7 @@ export class TreeImpl implements Tree {
         return parent;
     }
 
-    protected removeNode(node: TreeNode | undefined): void {
+    removeNode(node: TreeNode | undefined): void {
         if (CompositeTreeNode.is(node)) {
             node.children.forEach(child => this.removeNode(child));
         }

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

@@ -15,11 +15,12 @@
 // *****************************************************************************
 
 import { Container } from 'inversify';
-import { ContributionProvider } from '../../common';
+import { ContributionProvider, ILogger } from '../../common';
 import { CorePreferences } from '../../common/core-preferences';
 import { FrontendApplicationContribution } from '../frontend-application-contribution';
 import { DefaultWindowService } from './default-window-service';
 import assert = require('assert');
+import { MockLogger } from '../../common/test/mock-logger';
 
 describe('DefaultWindowService', () => {
     class TestFrontendApplicationContribution implements FrontendApplicationContribution {
@@ -42,6 +43,7 @@ describe('DefaultWindowService', () => {
             .toConstantValue({
                 'application.confirmExit': confirmExit,
             });
+        container.bind(ILogger).to(MockLogger).inSingletonScope();
         return container.get(DefaultWindowService);
     }
     it('onWillStop should be called on every contribution (never)', () => {

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

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { inject, injectable, named } from 'inversify';
-import { Event, Emitter } from '../../common';
+import { Event, Emitter, ILogger } from '../../common';
 import { CorePreferences } from '../../common/core-preferences';
 import { ContributionProvider } from '../../common/contribution-provider';
 import { FrontendApplicationContribution, OnWillStopAction } from '../frontend-application-contribution';
@@ -43,6 +43,9 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
     @named(FrontendApplicationContribution)
     protected readonly contributions: ContributionProvider<FrontendApplicationContribution>;
 
+    @inject(ILogger) @named('core:DefaultWindowService')
+    protected readonly logger: ILogger;
+
     onStart(app: FrontendApplication): void {
         this.frontendApplication = app;
         this.registerUnloadListeners();
@@ -114,7 +117,7 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
             return true;
         }
         const preparedValues = await Promise.all(vetoes.map(e => e.prepare?.(stopReason)));
-        console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+        this.logger.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
         for (let i = 0; i < vetoes.length; i++) {
             try {
                 const result = await vetoes[i].action(preparedValues[i], stopReason);
@@ -122,10 +125,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
                     return false;
                 }
             } catch (e) {
-                console.error(e);
+                this.logger.error(e);
             }
         }
-        console.debug('OnWillStop actions resolved; allowing shutdown');
+        this.logger.debug('OnWillStop actions resolved; allowing shutdown');
         this.allowVetoes = false;
         return true;
     }
@@ -145,10 +148,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         const vetoes = this.collectContributionUnloadVetoes();
         if (vetoes.length) {
             // In the browser, we don't call the functions because this has to finish in a single tick, so we treat any desired action as a veto.
-            console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
+            this.logger.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
             return this.preventUnload(event);
         }
-        console.debug('Shutdown will proceed.');
+        this.logger.debug('Shutdown will proceed.');
     }
 
     /**

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

@@ -14,8 +14,9 @@
 // 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 { injectable, inject, named } from 'inversify';
 import { ServiceConnectionProvider } from '../../browser/messaging/service-connection-provider';
+import { ILogger } from '../../common/logger';
 import { ConnectionSource } from '../../browser/messaging/connection-source';
 
 @injectable()
@@ -25,15 +26,19 @@ export class FrontendOnlyConnectionSource implements ConnectionSource {
 
 @injectable()
 export class FrontendOnlyServiceConnectionProvider extends ServiceConnectionProvider {
+
+    @inject(ILogger) @named('core:FrontendOnlyServiceConnectionProvider')
+    protected readonly logger: ILogger;
+
     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}`);
+        this.logger.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');
+        this.logger.debug('[Frontend-Only Fallback] Listen to websocket connection requested');
     }
 }

package/src/common/command.ts

@@ -21,6 +21,7 @@ import { ContributionProvider } from './contribution-provider';
 import { nls } from './nls';
 import debounce = require('p-debounce');
 import { isObject } from './types';
+import { ILogger } from './logger';
 
 /**
  * A command is a unique identifier of a function
@@ -190,6 +191,9 @@ export interface CommandService {
 @injectable()
 export class CommandRegistry implements CommandService {
 
+    @inject(ILogger) @named('core:CommandRegistry')
+    protected readonly logger: ILogger;
+
     protected readonly _commands: { [id: string]: Command } = {};
     protected readonly _handlers: { [id: string]: CommandHandler[] } = {};
 
@@ -232,7 +236,7 @@ export class CommandRegistry implements CommandService {
      */
     registerCommand(command: Command, handler?: CommandHandler): Disposable {
         if (this._commands[command.id]) {
-            console.warn(`A command ${command.id} is already registered.`);
+            this.logger.warn(`A command ${command.id} is already registered.`);
             return Disposable.NULL;
         }
         const toDispose = new DisposableCollection(this.doRegisterCommand(command));
@@ -363,7 +367,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }
@@ -383,7 +387,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }
@@ -403,7 +407,7 @@ export class CommandRegistry implements CommandService {
                         return handler;
                     }
                 } catch (error) {
-                    console.error(error);
+                    this.logger.error(error);
                 }
             }
         }