@theia/core 1.73.0-next.9 → 1.74.0-next.0

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