@theia/core 1.27.0-next.9 → 1.27.0

package/src/browser/tree/tree.ts

@@ -258,11 +258,15 @@ export class TreeImpl implements Tree {
         return this._root;
     }
 
+    protected toDisposeOnSetRoot = new DisposableCollection();
     set root(root: TreeNode | undefined) {
+        this.toDisposeOnSetRoot.dispose();
+        const cancelRefresh = new CancellationTokenSource();
+        this.toDisposeOnSetRoot.push(cancelRefresh);
         this.nodes = {};
         this._root = root;
         this.addNode(root);
-        this.refresh();
+        this.refresh(undefined, cancelRefresh.token);
     }
 
     get onChanged(): Event<void> {
@@ -291,7 +295,7 @@ export class TreeImpl implements Tree {
         return this.getNode(id);
     }
 
-    async refresh(raw?: CompositeTreeNode): Promise<CompositeTreeNode | undefined> {
+    async refresh(raw?: CompositeTreeNode, cancellationToken?: CancellationToken): Promise<CompositeTreeNode | undefined> {
         const parent = !raw ? this._root : this.validateNode(raw);
         let result: CompositeTreeNode | undefined;
         if (CompositeTreeNode.is(parent)) {
@@ -300,7 +304,9 @@ export class TreeImpl implements Tree {
             try {
                 result = parent;
                 const children = await this.resolveChildren(parent);
+                if (cancellationToken?.isCancellationRequested) { return; }
                 result = await this.setChildren(parent, children);
+                if (cancellationToken?.isCancellationRequested) { return; }
             } finally {
                 busySource.cancel();
             }

package/src/browser/view-container.ts

@@ -57,12 +57,23 @@ export interface DescriptionWidget {
     onDidChangeDescription: Emitter<void>;
 }
 
+export interface BadgeWidget {
+    badge: number | undefined;
+    onDidChangeBadge: Emitter<void>;
+}
+
 export namespace DescriptionWidget {
     export function is(arg: Object | undefined): arg is DescriptionWidget {
         return !!arg && typeof arg === 'object' && 'onDidChangeDescription' in arg;
     }
 }
 
+export namespace BadgeWidget {
+    export function is(arg: Object | undefined): arg is BadgeWidget {
+        return !!arg && typeof arg === 'object' && 'onDidChangeBadge' in arg;
+    }
+}
+
 /**
  * A view container holds an arbitrary number of widgets inside a split panel.
  * Each widget is wrapped in a _part_ that displays the widget title and toolbar
@@ -912,10 +923,7 @@ export class ViewContainerPart extends BaseWidget {
     protected readonly body: HTMLElement;
     protected readonly collapsedEmitter = new Emitter<boolean>();
     protected readonly contextMenuEmitter = new Emitter<MouseEvent>();
-    /**
-     * @deprecated since 0.11.0, use `onDidChangeVisibility` instead
-     */
-    readonly onVisibilityChanged = this.onDidChangeVisibility;
+
     protected readonly onTitleChangedEmitter = new Emitter<void>();
     readonly onTitleChanged = this.onTitleChangedEmitter.event;
     protected readonly onDidFocusEmitter = new Emitter<this>();
@@ -924,6 +932,8 @@ export class ViewContainerPart extends BaseWidget {
     readonly onDidMove = this.onPartMovedEmitter.event;
     protected readonly onDidChangeDescriptionEmitter = new Emitter<void>();
     readonly onDidChangeDescription = this.onDidChangeDescriptionEmitter.event;
+    protected readonly onDidChangeBadgeEmitter = new Emitter<void>();
+    readonly onDidChangeBadge = this.onDidChangeBadgeEmitter.event;
 
     protected readonly toolbar: TabBarToolbar;
 
@@ -959,6 +969,11 @@ export class ViewContainerPart extends BaseWidget {
             this.toDispose.push(this.wrapped?.onDidChangeDescription.event(fireDescriptionChanged));
         }
 
+        if (BadgeWidget.is(this.wrapped)) {
+            const fireBadgeChanged = () => this.onDidChangeBadgeEmitter.fire(undefined);
+            this.toDispose.push(this.wrapped?.onDidChangeBadge.event(fireBadgeChanged));
+        }
+
         const { header, body, disposable } = this.createContent();
         this.header = header;
         this.body = body;
@@ -975,6 +990,7 @@ export class ViewContainerPart extends BaseWidget {
             this.contextMenuEmitter,
             this.onTitleChangedEmitter,
             this.onDidChangeDescriptionEmitter,
+            this.onDidChangeBadgeEmitter,
             this.registerContextMenu(),
             this.onDidFocusEmitter,
             // focus event does not bubble, capture it
@@ -1142,6 +1158,14 @@ export class ViewContainerPart extends BaseWidget {
         const description = document.createElement('span');
         description.classList.add('description');
 
+        const badgeSpan = document.createElement('span');
+        badgeSpan.classList.add('notification-count');
+
+        const badgeContainer = document.createElement('div');
+        badgeContainer.classList.add('notification-count-container');
+        badgeContainer.appendChild(badgeSpan);
+        const badgeContainerDisplay = badgeContainer.style.display;
+
         const updateTitle = () => {
             if (this.currentContainerId !== this.originalContainerId && this.originalContainerTitle?.label) {
                 // Creating a title in format: <original_container_title>: <part_title>.
@@ -1154,20 +1178,33 @@ export class ViewContainerPart extends BaseWidget {
         const updateDescription = () => {
             description.innerText = DescriptionWidget.is(this.wrapped) && !this.collapsed && this.wrapped.description || '';
         };
+        const updateBadge = () => {
+            const visibleToolBarItems = this.toolbarRegistry.visibleItems(this.wrapped).length > 0;
+            const badge = BadgeWidget.is(this.wrapped) && this.wrapped.badge;
+            if (typeof badge === 'number' && !visibleToolBarItems) {
+                badgeSpan.innerText = badge.toString();
+                badgeContainer.style.display = badgeContainerDisplay;
+            } else {
+                badgeContainer.style.display = 'none';
+            }
+        };
 
         updateTitle();
         updateCaption();
         updateDescription();
+        updateBadge();
 
         disposable.pushAll([
             this.onTitleChanged(updateTitle),
             this.onTitleChanged(updateCaption),
             this.onDidMove(updateTitle),
             this.onDidChangeDescription(updateDescription),
+            this.onDidChangeBadge(updateBadge),
             this.onCollapsed(updateDescription)
         ]);
         header.appendChild(title);
         header.appendChild(description);
+        header.appendChild(badgeContainer);
 
         return {
             header,

package/src/common/cancellation.ts

@@ -49,6 +49,14 @@ export namespace CancellationToken {
         isCancellationRequested: true,
         onCancellationRequested: shortcutEvent
     });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    export function is(value: any): value is CancellationToken {
+        const candidate = value as CancellationToken;
+        return candidate && (candidate === CancellationToken.None
+            || candidate === CancellationToken.Cancelled
+            || (typeof candidate.isCancellationRequested === 'boolean' && !!candidate.onCancellationRequested));
+    }
 }
 
 export class CancellationError extends Error {

package/src/common/command.ts

@@ -191,7 +191,7 @@ export class CommandRegistry implements CommandService {
     protected readonly toUnregisterCommands = new Map<string, Disposable>();
 
     // List of recently used commands.
-    protected _recent: Command[] = [];
+    protected _recent: string[] = [];
 
     protected readonly onWillExecuteCommandEmitter = new Emitter<WillExecuteCommandEvent>();
     readonly onWillExecuteCommand = this.onWillExecuteCommandEmitter.event;
@@ -418,14 +418,7 @@ export class CommandRegistry implements CommandService {
      * Get all registered commands.
      */
     get commands(): Command[] {
-        const commands: Command[] = [];
-        for (const id of this.commandIds) {
-            const cmd = this.getCommand(id);
-            if (cmd) {
-                commands.push(cmd);
-            }
-        }
-        return commands;
+        return Object.values(this._commands);
     }
 
     /**
@@ -446,7 +439,14 @@ export class CommandRegistry implements CommandService {
      * Get the list of recently used commands.
      */
     get recent(): Command[] {
-        return this._recent;
+        const commands: Command[] = [];
+        for (const recentId of this._recent) {
+            const command = this.getCommand(recentId);
+            if (command) {
+                commands.push(command);
+            }
+        }
+        return commands;
     }
 
     /**
@@ -454,7 +454,7 @@ export class CommandRegistry implements CommandService {
      * @param commands the list of recently used commands.
      */
     set recent(commands: Command[]) {
-        this._recent = commands;
+        this._recent = Array.from(new Set(commands.map(e => e.id)));
     }
 
     /**
@@ -464,15 +464,13 @@ export class CommandRegistry implements CommandService {
      * @param recent a recent command, or array of recent commands.
      */
     addRecentCommand(recent: Command | Command[]): void {
-        if (Array.isArray(recent)) {
-            recent.forEach((command: Command) => this.addRecentCommand(command));
-        } else {
+        for (const recentCommand of Array.isArray(recent) ? recent : [recent]) {
             // Determine if the command currently exists in the recently used list.
-            const index = this._recent.findIndex((command: Command) => Command.equals(recent, command));
+            const index = this._recent.findIndex(commandId => commandId === recentCommand.id);
             // If the command exists, remove it from the array so it can later be placed at the top.
             if (index >= 0) { this._recent.splice(index, 1); }
             // Add the recent command to the beginning of the array (most recent).
-            this._recent.unshift(recent);
+            this._recent.unshift(recentCommand.id);
         }
     }
 

package/src/common/index.ts

@@ -29,6 +29,7 @@ export * from './contribution-provider';
 export * from './path';
 export * from './logger';
 export * from './messaging';
+export * from './message-rpc';
 export * from './message-service';
 export * from './message-service-protocol';
 export * from './progress-service';

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

@@ -0,0 +1,88 @@
+// *****************************************************************************
+// Copyright (C) 2021 Red Hat, Inc. 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { assert, expect, spy, use } from 'chai';
+import * as spies from 'chai-spies';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from './uint8-array-message-buffer';
+import { ChannelMultiplexer, ForwardingChannel, MessageProvider } from './channel';
+
+use(spies);
+
+/**
+ * A pipe with two channels at each end for testing.
+ */
+export class ChannelPipe {
+    readonly left: ForwardingChannel = new ForwardingChannel('left', () => this.right.onCloseEmitter.fire({ reason: 'Left channel has been closed' }), () => {
+        const leftWrite = new Uint8ArrayWriteBuffer();
+        leftWrite.onCommit(buffer => {
+            this.right.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(buffer));
+        });
+        return leftWrite;
+    });
+    readonly right: ForwardingChannel = new ForwardingChannel('right', () => this.left.onCloseEmitter.fire({ reason: 'Right channel has been closed' }), () => {
+        const rightWrite = new Uint8ArrayWriteBuffer();
+        rightWrite.onCommit(buffer => {
+            this.left.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(buffer));
+        });
+        return rightWrite;
+    });
+}
+describe('Message Channel', () => {
+    describe('Channel multiplexer', () => {
+        it('should forward messages to intended target channel', async () => {
+            const pipe = new ChannelPipe();
+
+            const leftMultiplexer = new ChannelMultiplexer(pipe.left);
+            const rightMultiplexer = new ChannelMultiplexer(pipe.right);
+            const openChannelSpy = spy(() => {
+            });
+
+            rightMultiplexer.onDidOpenChannel(openChannelSpy);
+            leftMultiplexer.onDidOpenChannel(openChannelSpy);
+
+            const leftFirst = await leftMultiplexer.open('first');
+            const leftSecond = await leftMultiplexer.open('second');
+
+            const rightFirst = rightMultiplexer.getOpenChannel('first');
+            const rightSecond = rightMultiplexer.getOpenChannel('second');
+
+            assert.isNotNull(rightFirst);
+            assert.isNotNull(rightSecond);
+
+            const leftSecondSpy = spy((buf: MessageProvider) => {
+                const message = buf().readString();
+                expect(message).equal('message for second');
+            });
+
+            leftSecond.onMessage(leftSecondSpy);
+
+            const rightFirstSpy = spy((buf: MessageProvider) => {
+                const message = buf().readString();
+                expect(message).equal('message for first');
+            });
+
+            rightFirst!.onMessage(rightFirstSpy);
+
+            leftFirst.getWriteBuffer().writeString('message for first').commit();
+            rightSecond!.getWriteBuffer().writeString('message for second').commit();
+
+            expect(leftSecondSpy).to.be.called();
+            expect(rightFirstSpy).to.be.called();
+
+            expect(openChannelSpy).to.be.called.exactly(4);
+        });
+    });
+});

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

@@ -0,0 +1,260 @@
+// *****************************************************************************
+// Copyright (C) 2021 Red Hat, Inc. 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Disposable, DisposableCollection } from '../disposable';
+import { Emitter, Event } from '../event';
+import { ReadBuffer, WriteBuffer } from './message-buffer';
+
+/**
+ * A channel is a bidirectional communications channel with lifecycle and
+ * error signalling. Note that creation of channels is specific to particular
+ * implementations and thus not part of the protocol.
+ */
+export interface Channel {
+
+    /**
+     * The remote side has closed the channel
+     */
+    onClose: Event<ChannelCloseEvent>;
+
+    /**
+     * An error has occurred while writing to or reading from the channel
+     */
+    onError: Event<unknown>;
+
+    /**
+     * A message has arrived and can be read  by listeners using a {@link MessageProvider}.
+     */
+    onMessage: Event<MessageProvider>;
+
+    /**
+     * Obtain a {@link WriteBuffer} to write a message to the channel.
+     */
+    getWriteBuffer(): WriteBuffer;
+
+    /**
+     * Close this channel. No {@link onClose} event should be sent
+     */
+    close(): void;
+}
+
+/**
+ * The event that is emitted when a channel is closed from the remote side.
+ */
+export interface ChannelCloseEvent {
+    reason: string,
+    code?: number
+};
+
+/**
+ * The `MessageProvider` is emitted when a channel receives a new message.
+ * Listeners can invoke the provider to obtain a new {@link ReadBuffer} for the received message.
+ * This ensures that each listener has its own isolated {@link ReadBuffer} instance.
+ *
+ */
+export type MessageProvider = () => ReadBuffer;
+
+/**
+ * Helper class to implement the single channels on a {@link ChannelMultiplexer}. Simply forwards write requests to
+ * the given write buffer source i.e. the main channel of the {@link ChannelMultiplexer}.
+ */
+export class ForwardingChannel implements Channel {
+
+    protected toDispose = new DisposableCollection();
+    constructor(readonly id: string, protected readonly closeHandler: () => void, protected readonly writeBufferSource: () => WriteBuffer) {
+        this.toDispose.pushAll([this.onCloseEmitter, this.onErrorEmitter, this.onMessageEmitter]);
+    }
+
+    onCloseEmitter: Emitter<ChannelCloseEvent> = new Emitter();
+    get onClose(): Event<ChannelCloseEvent> {
+        return this.onCloseEmitter.event;
+    };
+
+    onErrorEmitter: Emitter<unknown> = new Emitter();
+    get onError(): Event<unknown> {
+        return this.onErrorEmitter.event;
+    };
+
+    onMessageEmitter: Emitter<MessageProvider> = new Emitter();
+    get onMessage(): Event<MessageProvider> {
+        return this.onMessageEmitter.event;
+    };
+
+    getWriteBuffer(): WriteBuffer {
+        return this.writeBufferSource();
+    }
+
+    close(): void {
+        this.closeHandler();
+        this.toDispose.dispose();
+    }
+}
+
+/**
+ * The different message types used in the messaging protocol of the {@link ChannelMultiplexer}
+ */
+export enum MessageTypes {
+    Open = 1,
+    Close = 2,
+    AckOpen = 3,
+    Data = 4
+}
+
+/**
+ * The write buffers in this implementation immediately write to the underlying
+ * channel, so we rely on writers to the multiplexed channels to always commit their
+ * messages and always in one go.
+ */
+export class ChannelMultiplexer implements Disposable {
+    protected pendingOpen: Map<string, (channel: ForwardingChannel) => void> = new Map();
+    protected openChannels: Map<string, ForwardingChannel> = new Map();
+
+    protected readonly onOpenChannelEmitter = new Emitter<{ id: string, channel: Channel }>();
+    get onDidOpenChannel(): Event<{ id: string, channel: Channel }> {
+        return this.onOpenChannelEmitter.event;
+    }
+
+    protected toDispose = new DisposableCollection();
+
+    constructor(protected readonly underlyingChannel: Channel) {
+        this.toDispose.pushAll([
+            this.underlyingChannel.onMessage(buffer => this.handleMessage(buffer())),
+            this.underlyingChannel.onClose(event => this.onUnderlyingChannelClose(event)),
+            this.underlyingChannel.onError(error => this.handleError(error)),
+            this.onOpenChannelEmitter
+        ]);
+    }
+
+    protected handleError(error: unknown): void {
+        this.openChannels.forEach(channel => {
+            channel.onErrorEmitter.fire(error);
+        });
+    }
+
+    onUnderlyingChannelClose(event?: ChannelCloseEvent): void {
+        if (!this.toDispose.disposed) {
+            this.toDispose.push(Disposable.create(() => {
+                this.pendingOpen.clear();
+                this.openChannels.forEach(channel => {
+                    channel.onCloseEmitter.fire(event ?? { reason: 'Multiplexer main channel has been closed from the remote side!' });
+                });
+
+                this.openChannels.clear();
+            }));
+            this.dispose();
+        }
+
+    }
+
+    protected handleMessage(buffer: ReadBuffer): void {
+        const type = buffer.readUint8();
+        const id = buffer.readString();
+        switch (type) {
+            case MessageTypes.AckOpen: {
+                return this.handleAckOpen(id);
+            }
+            case MessageTypes.Open: {
+                return this.handleOpen(id);
+            }
+            case MessageTypes.Close: {
+                return this.handleClose(id);
+            }
+            case MessageTypes.Data: {
+                return this.handleData(id, buffer.sliceAtReadPosition());
+            }
+        }
+    }
+
+    protected handleAckOpen(id: string): void {
+        // edge case: both side try to open a channel at the same time.
+        const resolve = this.pendingOpen.get(id);
+        if (resolve) {
+            const channel = this.createChannel(id);
+            this.pendingOpen.delete(id);
+            this.openChannels.set(id, channel);
+            resolve!(channel);
+            this.onOpenChannelEmitter.fire({ id, channel });
+        }
+    }
+
+    protected handleOpen(id: string): void {
+        if (!this.openChannels.has(id)) {
+            const channel = this.createChannel(id);
+            this.openChannels.set(id, channel);
+            const resolve = this.pendingOpen.get(id);
+            if (resolve) {
+                // edge case: both side try to open a channel at the same time.
+                resolve(channel);
+            }
+            this.underlyingChannel.getWriteBuffer().writeUint8(MessageTypes.AckOpen).writeString(id).commit();
+            this.onOpenChannelEmitter.fire({ id, channel });
+        }
+    }
+
+    protected handleClose(id: string): void {
+        const channel = this.openChannels.get(id);
+        if (channel) {
+            channel.onCloseEmitter.fire({ reason: 'Channel has been closed from the remote side' });
+            this.openChannels.delete(id);
+        }
+    }
+
+    protected handleData(id: string, data: ReadBuffer): void {
+        const channel = this.openChannels.get(id);
+        if (channel) {
+            channel.onMessageEmitter.fire(() => data);
+        }
+    }
+
+    protected createChannel(id: string): ForwardingChannel {
+        return new ForwardingChannel(id, () => this.closeChannel(id), () => this.prepareWriteBuffer(id));
+    }
+
+    // Prepare the write buffer for the channel with the give, id. The channel id has to be encoded
+    // and written to the buffer before the actual message.
+    protected prepareWriteBuffer(id: string): WriteBuffer {
+        const underlying = this.underlyingChannel.getWriteBuffer();
+        underlying.writeUint8(MessageTypes.Data);
+        underlying.writeString(id);
+        return underlying;
+    }
+
+    protected closeChannel(id: string): void {
+        this.underlyingChannel.getWriteBuffer()
+            .writeUint8(MessageTypes.Close)
+            .writeString(id)
+            .commit();
+
+        this.openChannels.delete(id);
+    }
+
+    open(id: string): Promise<Channel> {
+        const result = new Promise<Channel>((resolve, reject) => {
+            this.pendingOpen.set(id, resolve);
+        });
+        this.underlyingChannel.getWriteBuffer().writeUint8(MessageTypes.Open).writeString(id).commit();
+        return result;
+    }
+
+    getOpenChannel(id: string): Channel | undefined {
+        return this.openChannels.get(id);
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+}
+

package/src/{node/messaging/logger.ts → common/message-rpc/index.ts}

@@ -1,5 +1,5 @@
 // *****************************************************************************
-// Copyright (C) 2017 TypeFox and others.
+// Copyright (C) 2022 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
@@ -13,25 +13,6 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
-
-import { Logger } from 'vscode-ws-jsonrpc';
-
-export class ConsoleLogger implements Logger {
-
-    error(message: string): void {
-        console.log(message);
-    }
-
-    warn(message: string): void {
-        console.log(message);
-    }
-
-    info(message: string): void {
-        console.log(message);
-    }
-
-    log(message: string): void {
-        console.log(message);
-    }
-
-}
+export { RequestHandler, RpcProtocol, RpcProtocolOptions } from './rpc-protocol';
+export { Channel, ChannelCloseEvent, MessageProvider } from './channel';
+export { ReadBuffer, WriteBuffer } from './message-buffer';