@theia/plugin-ext 1.34.0-next.7 → 1.34.1

package/src/main/browser/tabs/tabs-main.ts

@@ -15,16 +15,275 @@
 // *****************************************************************************
 
 import { interfaces } from '@theia/core/shared/inversify';
-
-import { TabsMain } from '../../../common/plugin-api-rpc';
+import { ApplicationShell, PINNED_CLASS, Saveable, TabBar, Title, ViewContainer, Widget } from '@theia/core/lib/browser';
+import { AnyInputDto, MAIN_RPC_CONTEXT, TabDto, TabGroupDto, TabInputKind, TabModelOperationKind, TabsExt, TabsMain } from '../../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../../common/rpc-protocol';
+import { EditorPreviewWidget } from '@theia/editor-preview/lib/browser/editor-preview-widget';
+import { Disposable } from '@theia/core/shared/vscode-languageserver-protocol';
+import { MonacoDiffEditor } from '@theia/monaco/lib/browser/monaco-diff-editor';
+import { toUriComponents } from '../hierarchy/hierarchy-types-converters';
+import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
+import { DisposableCollection } from '@theia/core';
+
+interface TabInfo {
+    tab: TabDto;
+    tabIndex: number;
+    group: TabGroupDto;
+}
+
+export class TabsMainImpl implements TabsMain, Disposable {
+
+    private readonly proxy: TabsExt;
+    private tabGroupModel = new Map<TabBar<Widget>, TabGroupDto>();
+    private tabInfoLookup = new Map<Title<Widget>, TabInfo>();
+
+    private applicationShell: ApplicationShell;
+
+    private disposableTabBarListeners: DisposableCollection = new DisposableCollection();
+    private toDisposeOnDestroy: DisposableCollection = new DisposableCollection();
 
-export class TabsMainImp implements TabsMain {
+    private groupIdCounter = 0;
+    private currentActiveGroup: TabGroupDto;
+
+    private tabGroupChanged: boolean = false;
 
     constructor(
         rpc: RPCProtocol,
         container: interfaces.Container
-    ) {}
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.TABS_EXT);
+
+        this.applicationShell = container.get(ApplicationShell);
+        this.createTabsModel();
+
+        const tabBars = this.applicationShell.mainPanel.tabBars();
+        for (let tabBar; tabBar = tabBars.next();) {
+            this.attachListenersToTabBar(tabBar);
+        }
+
+        this.toDisposeOnDestroy.push(
+            this.applicationShell.mainPanelRenderer.onDidCreateTabBar(tabBar => {
+                this.attachListenersToTabBar(tabBar);
+                this.onTabGroupCreated(tabBar);
+            })
+        );
+
+        this.connectToSignal(this.toDisposeOnDestroy, this.applicationShell.mainPanel.widgetAdded, (mainPanel, widget) => {
+            if (this.tabGroupChanged || this.tabGroupModel.size === 0) {
+                this.tabGroupChanged = false;
+                this.createTabsModel();
+                // tab Open event is done in backend
+            } else {
+                const tabBar = mainPanel.findTabBar(widget.title)!;
+                const oldTabInfo = this.tabInfoLookup.get(widget.title);
+                const group = this.tabGroupModel.get(tabBar);
+                if (group !== oldTabInfo?.group) {
+                    if (oldTabInfo) {
+                        this.onTabClosed(oldTabInfo, widget.title);
+                    }
+
+                    this.onTabCreated(tabBar, { index: tabBar.titles.indexOf(widget.title), title: widget.title });
+                }
+            }
+        });
+
+        this.connectToSignal(this.toDisposeOnDestroy, this.applicationShell.mainPanel.widgetRemoved, (mainPanel, widget) => {
+            if (!(widget instanceof TabBar)) {
+                const tabInfo = this.getOrRebuildModel(this.tabInfoLookup, widget.title)!;
+                this.onTabClosed(tabInfo, widget.title);
+                if (this.tabGroupChanged) {
+                    this.tabGroupChanged = false;
+                    this.createTabsModel();
+                }
+            }
+        });
+    }
+
+    protected createTabsModel(): void {
+        const newTabGroupModel = new Map<TabBar<Widget>, TabGroupDto>();
+        this.tabInfoLookup.clear();
+        this.disposableTabBarListeners.dispose();
+        this.applicationShell.mainAreaTabBars.forEach(tabBar => {
+            this.attachListenersToTabBar(tabBar);
+            const groupDto = this.createTabGroupDto(tabBar);
+            tabBar.titles.forEach((title, index) => this.tabInfoLookup.set(title, { group: groupDto, tab: groupDto.tabs[index], tabIndex: index }));
+            newTabGroupModel.set(tabBar, groupDto);
+        });
+        if (newTabGroupModel.size > 0 && Array.from(newTabGroupModel.values()).indexOf(this.currentActiveGroup) < 0) {
+            this.currentActiveGroup = this.tabInfoLookup.get(this.applicationShell.mainPanel.currentTitle!)?.group ?? newTabGroupModel.values().next().value;
+            this.currentActiveGroup.isActive = true;
+        }
+        this.tabGroupModel = newTabGroupModel;
+        this.proxy.$acceptEditorTabModel(Array.from(this.tabGroupModel.values()));
+    }
+
+    protected createTabDto(tabTitle: Title<Widget>, groupId: number): TabDto {
+        const widget = tabTitle.owner;
+        return {
+            id: this.createTabId(tabTitle, groupId),
+            label: tabTitle.label,
+            input: this.evaluateTabDtoInput(widget),
+            isActive: tabTitle.owner.isVisible,
+            isPinned: tabTitle.className.includes(PINNED_CLASS),
+            isDirty: Saveable.isDirty(widget),
+            isPreview: widget instanceof EditorPreviewWidget && widget.isPreview
+        };
+    }
+
+    protected createTabId(tabTitle: Title<Widget>, groupId: number): string {
+        return `${groupId}~${tabTitle.owner.id}`;
+    }
+
+    protected createTabGroupDto(tabBar: TabBar<Widget>): TabGroupDto {
+        const oldDto = this.tabGroupModel.get(tabBar);
+        const groupId = oldDto?.groupId ?? this.groupIdCounter++;
+        const tabs = tabBar.titles.map(title => this.createTabDto(title, groupId));
+        return {
+            groupId,
+            tabs,
+            isActive: false,
+            viewColumn: 1
+        };
+    }
+
+    protected attachListenersToTabBar(tabBar: TabBar<Widget> | undefined): void {
+        if (!tabBar) {
+            return;
+        }
+        tabBar.titles.forEach(title => {
+            this.connectToSignal(this.disposableTabBarListeners, title.changed, this.onTabTitleChanged);
+        });
+
+        this.connectToSignal(this.disposableTabBarListeners, tabBar.tabMoved, this.onTabMoved);
+        this.connectToSignal(this.disposableTabBarListeners, tabBar.disposed, this.onTabGroupClosed);
+    }
+
+    protected evaluateTabDtoInput(widget: Widget): AnyInputDto {
+        if (widget instanceof EditorPreviewWidget) {
+            if (widget.editor instanceof MonacoDiffEditor) {
+                return {
+                    kind: TabInputKind.TextDiffInput,
+                    original: toUriComponents(widget.editor.originalModel.uri),
+                    modified: toUriComponents(widget.editor.modifiedModel.uri)
+                };
+            } else {
+                return {
+                    kind: TabInputKind.TextInput,
+                    uri: toUriComponents(widget.editor.uri.toString())
+                };
+            }
+            // TODO notebook support when implemented
+        } else if (widget instanceof ViewContainer) {
+            return {
+                kind: TabInputKind.WebviewEditorInput,
+                viewType: widget.id
+            };
+        } else if (widget instanceof TerminalWidget) {
+            return {
+                kind: TabInputKind.TerminalEditorInput
+            };
+        }
+
+        return { kind: TabInputKind.UnknownInput };
+    }
+
+    protected connectToSignal<T>(disposableList: DisposableCollection, signal: { connect(listener: T, context: unknown): void, disconnect(listener: T): void }, listener: T): void {
+        signal.connect(listener, this);
+        disposableList.push(Disposable.create(() => signal.disconnect(listener)));
+    }
+
+    protected tabDtosEqual(a: TabDto, b: TabDto): boolean {
+        return a.isActive === b.isActive &&
+            a.isDirty === b.isDirty &&
+            a.isPinned === b.isPinned &&
+            a.isPreview === b.isPreview &&
+            a.id === b.id;
+    }
+
+    protected getOrRebuildModel<T, R>(map: Map<T, R>, key: T): R {
+        // something broke so we rebuild the model
+        let item = map.get(key);
+        if (!item) {
+            this.createTabsModel();
+            item = map.get(key)!;
+        }
+        return item;
+    }
+
+    // #region event listeners
+    private onTabCreated(tabBar: TabBar<Widget>, args: TabBar.ITabActivateRequestedArgs<Widget>): void {
+        const group = this.getOrRebuildModel(this.tabGroupModel, tabBar);
+        this.connectToSignal(this.disposableTabBarListeners, args.title.changed, this.onTabTitleChanged);
+        const tabDto = this.createTabDto(args.title, group.groupId);
+        this.tabInfoLookup.set(args.title, { group, tab: tabDto, tabIndex: args.index });
+        group.tabs.splice(args.index, 0, tabDto);
+        this.proxy.$acceptTabOperation({
+            kind: TabModelOperationKind.TAB_OPEN,
+            index: args.index,
+            tabDto,
+            groupId: group.groupId
+        });
+    }
+
+    private onTabTitleChanged(title: Title<Widget>): void {
+        const tabInfo = this.getOrRebuildModel(this.tabInfoLookup, title);
+        if (!tabInfo) {
+            return;
+        }
+        const oldTabDto = tabInfo.tab;
+        const newTabDto = this.createTabDto(title, tabInfo.group.groupId);
+        if (newTabDto.isActive && !tabInfo.group.isActive) {
+            tabInfo.group.isActive = true;
+            this.currentActiveGroup.isActive = false;
+            this.currentActiveGroup = tabInfo.group;
+            this.proxy.$acceptTabGroupUpdate(tabInfo.group);
+        }
+        if (!this.tabDtosEqual(oldTabDto, newTabDto)) {
+            tabInfo.group.tabs[tabInfo.tabIndex] = newTabDto;
+            tabInfo.tab = newTabDto;
+            this.proxy.$acceptTabOperation({
+                kind: TabModelOperationKind.TAB_UPDATE,
+                index: tabInfo.tabIndex,
+                tabDto: newTabDto,
+                groupId: tabInfo.group.groupId
+            });
+        }
+    }
+
+    private onTabClosed(tabInfo: TabInfo, title: Title<Widget>): void {
+        tabInfo.group.tabs.splice(tabInfo.tabIndex, 1);
+        this.tabInfoLookup.delete(title);
+        this.proxy.$acceptTabOperation({
+            kind: TabModelOperationKind.TAB_CLOSE,
+            index: tabInfo.tabIndex,
+            tabDto: this.createTabDto(title, tabInfo.group.groupId),
+            groupId: tabInfo.group.groupId
+        });
+    }
+
+    private onTabMoved(tabBar: TabBar<Widget>, args: TabBar.ITabMovedArgs<Widget>): void {
+        const tabInfo = this.getOrRebuildModel(this.tabInfoLookup, args.title)!;
+        tabInfo.tabIndex = args.toIndex;
+        const tabDto = this.createTabDto(args.title, tabInfo.group.groupId);
+        tabInfo.group.tabs.splice(args.fromIndex, 1);
+        tabInfo.group.tabs.splice(args.toIndex, 0, tabDto);
+        this.proxy.$acceptTabOperation({
+            kind: TabModelOperationKind.TAB_MOVE,
+            index: args.toIndex,
+            tabDto,
+            groupId: tabInfo.group.groupId,
+            oldIndex: args.fromIndex
+        });
+    }
+
+    private onTabGroupCreated(tabBar: TabBar<Widget>): void {
+        this.tabGroupChanged = true;
+    }
+
+    private onTabGroupClosed(tabBar: TabBar<Widget>): void {
+        this.tabGroupChanged = true;
+    }
+    // #endregion
 
     // #region Messages received from Ext Host
     $moveTab(tabId: string, index: number, viewColumn: number, preserveFocus?: boolean): void {
@@ -32,11 +291,33 @@ export class TabsMainImp implements TabsMain {
     }
 
     async $closeTab(tabIds: string[], preserveFocus?: boolean): Promise<boolean> {
-        return false;
+        const widgets: Widget[] = [];
+        for (const tabId of tabIds) {
+            const cleanedId = tabId.substring(tabId.indexOf('~') + 1);
+            const widget = this.applicationShell.getWidgetById(cleanedId);
+            if (widget) {
+                widgets.push(widget);
+            }
+        }
+        await this.applicationShell.closeMany(widgets);
+        return true;
     }
 
     async $closeGroup(groupIds: number[], preserveFocus?: boolean): Promise<boolean> {
-        return false;
+        for (const groupId of groupIds) {
+            tabGroupModel: for (const [bar, groupDto] of this.tabGroupModel) {
+                if (groupDto.groupId === groupId) {
+                    this.applicationShell.closeTabs(bar);
+                    break tabGroupModel;
+                }
+            }
+        }
+        return true;
     }
     // #endregion
+
+    dispose(): void {
+        this.toDisposeOnDestroy.dispose();
+        this.disposableTabBarListeners.dispose();
+    }
 }

package/src/main/browser/terminal-main.ts

@@ -16,9 +16,8 @@
 
 import { interfaces } from '@theia/core/shared/inversify';
 import { ApplicationShell, WidgetOpenerOptions } from '@theia/core/lib/browser';
-import { TerminalOptions } from '@theia/plugin';
-import { CancellationToken } from '@theia/core/shared/vscode-languageserver-protocol';
-import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
+import { TerminalEditorLocationOptions, TerminalOptions } from '@theia/plugin';
+import { TerminalLocation, TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
 import { TerminalServiceMain, TerminalServiceExt, MAIN_RPC_CONTEXT } from '../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../common/rpc-protocol';
@@ -27,6 +26,10 @@ import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/c
 import { ShellTerminalServerProxy } from '@theia/terminal/lib/common/shell-terminal-protocol';
 import { TerminalLink, TerminalLinkProvider } from '@theia/terminal/lib/browser/terminal-link-provider';
 import { URI } from '@theia/core/lib/common/uri';
+import { getIconClass } from '../../plugin/terminal-ext';
+import { PluginTerminalRegistry } from './plugin-terminal-registry';
+import { CancellationToken } from '@theia/core';
+import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
 
 /**
  * Plugin api service allows working with terminal emulator.
@@ -34,6 +37,8 @@ import { URI } from '@theia/core/lib/common/uri';
 export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLinkProvider, Disposable {
 
     private readonly terminals: TerminalService;
+    private readonly pluginTerminalRegistry: PluginTerminalRegistry;
+    private readonly hostedPluginSupport: HostedPluginSupport;
     private readonly shell: ApplicationShell;
     private readonly extProxy: TerminalServiceExt;
     private readonly shellTerminalServer: ShellTerminalServerProxy;
@@ -43,6 +48,8 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
 
     constructor(rpc: RPCProtocol, container: interfaces.Container) {
         this.terminals = container.get(TerminalService);
+        this.pluginTerminalRegistry = container.get(PluginTerminalRegistry);
+        this.hostedPluginSupport = container.get(HostedPluginSupport);
         this.shell = container.get(ApplicationShell);
         this.shellTerminalServer = container.get(ShellTerminalServerProxy);
         this.extProxy = rpc.getProxy(MAIN_RPC_CONTEXT.TERMINAL_EXT);
@@ -58,9 +65,16 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
             this.extProxy.$initEnvironmentVariableCollections(serializedCollections);
         }
 
+        this.pluginTerminalRegistry.startCallback = id => this.startProfile(id);
+
         container.bind(TerminalLinkProvider).toDynamicValue(() => this);
     }
 
+    async startProfile(id: string): Promise<string> {
+        await this.hostedPluginSupport.activateByTerminalProfile(id);
+        return this.extProxy.$startProfile(id, CancellationToken.None);
+    }
+
     $setEnvironmentVariableCollection(extensionIdentifier: string, persistent: boolean, collection: SerializableEnvironmentVariableCollection | undefined): void {
         if (collection) {
             this.shellTerminalServer.setCollection(extensionIdentifier, persistent, collection);
@@ -122,30 +136,46 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         terminal.resize(cols, rows);
     }
 
-    async $createTerminal(id: string, options: TerminalOptions, isPseudoTerminal?: boolean): Promise<string> {
-        try {
-            const terminal = await this.terminals.newTerminal({
-                id,
-                title: options.name,
-                shellPath: options.shellPath,
-                shellArgs: options.shellArgs,
-                cwd: options.cwd ? new URI(options.cwd) : undefined,
-                env: options.env,
-                strictEnv: options.strictEnv,
-                destroyTermOnClose: true,
-                useServerTitle: false,
-                attributes: options.attributes,
-                hideFromUser: options.hideFromUser,
-                isPseudoTerminal
-            });
-            if (options.message) {
-                terminal.writeLine(options.message);
+    async $createTerminal(id: string, options: TerminalOptions, parentId?: string, isPseudoTerminal?: boolean): Promise<string> {
+        const terminal = await this.terminals.newTerminal({
+            id,
+            title: options.name,
+            iconClass: getIconClass(options),
+            shellPath: options.shellPath,
+            shellArgs: options.shellArgs,
+            cwd: options.cwd ? new URI(options.cwd) : undefined,
+            env: options.env,
+            strictEnv: options.strictEnv,
+            destroyTermOnClose: true,
+            useServerTitle: false,
+            attributes: options.attributes,
+            hideFromUser: options.hideFromUser,
+            location: this.getTerminalLocation(options, parentId),
+            isPseudoTerminal,
+            isTransient: options.isTransient
+        });
+        if (options.message) {
+            terminal.writeLine(options.message);
+        }
+        terminal.start();
+        return terminal.id;
+    }
+
+    protected getTerminalLocation(options: TerminalOptions, parentId?: string): TerminalLocation | TerminalEditorLocationOptions | { parentTerminal: string; } | undefined {
+        if (typeof options.location === 'number' && Object.values(TerminalLocation).includes(options.location)) {
+            return options.location;
+        } else if (options.location && typeof options.location === 'object') {
+            if ('parentTerminal' in options.location) {
+                if (!parentId) {
+                    throw new Error('parentTerminal is set but no parentId is provided');
+                }
+                return { 'parentTerminal': parentId };
+            } else {
+                return options.location;
             }
-            terminal.start();
-            return terminal.id;
-        } catch (error) {
-            throw new Error('Failed to create terminal. Cause: ' + error);
         }
+
+        return undefined;
     }
 
     $sendText(id: string, text: string, addNewLine?: boolean): void {

package/src/main/browser/view/dnd-file-content-store.ts

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// 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
+// 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 { injectable } from '@theia/core/shared/inversify';
+
+@injectable()
+export class DnDFileContentStore {
+    private static id: number = 0;
+    private files: Map<string, File> = new Map();
+
+    addFile(f: File): string {
+        const id = (DnDFileContentStore.id++).toString();
+        this.files.set(id, f);
+        return id;
+    }
+
+    removeFile(id: string): boolean {
+        return this.files.delete(id);
+    }
+
+    getFile(id: string): File {
+        const file = this.files.get(id);
+        if (file) {
+            return file;
+        }
+
+        throw new Error(`File with id ${id} not found in dnd operation`);
+    }
+}

package/src/main/browser/view/plugin-view-registry.ts

@@ -148,7 +148,10 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 const disposable = new DisposableCollection();
                 disposable.push(this.registerViewWelcome({
                     view: 'explorer',
-                    content: nls.localizeByDefault('You have not yet opened a folder.\n[Open Folder](command:{0})', 'workbench.action.files.openFolder'),
+                    content: nls.localizeByDefault(
+                        'You have not yet opened a folder.\n{0}',
+                        `[${nls.localizeByDefault('Open Folder')}](command:workbench.action.files.openFolder)`
+                    ),
                     order: 0
                 }));
                 disposable.push(event.widget.onDidDispose(() => disposable.dispose()));

package/src/main/browser/view/tree-view-decorator-service.ts

@@ -16,9 +16,9 @@
 
 import { inject, injectable, interfaces, named } from '@theia/core/shared/inversify';
 import { AbstractTreeDecoratorService, TreeDecorator } from '@theia/core/lib/browser/tree/tree-decorator';
-import { bindContributionProvider, ContributionProvider } from '@theia/core';
+import { bindContributionProvider, ContributionProvider, isObject } from '@theia/core';
 import { TreeNode } from '@theia/core/lib/browser';
-import { TreeItem, Uri } from '@theia/plugin';
+import { TreeItem } from '@theia/plugin';
 import URI from '@theia/core/lib/common/uri';
 import { FileTreeDecoratorAdapter } from '@theia/filesystem/lib/browser';
 
@@ -32,9 +32,8 @@ export class TreeViewDecoratorAdapter extends FileTreeDecoratorAdapter {
         }
     }
 
-    protected isTreeItem(node: unknown): node is TreeItem & { resourceUri: Uri } {
-        const candidate = node as TreeItem;
-        return !!candidate && typeof node === 'object' && 'resourceUri' in candidate && !!candidate.resourceUri;
+    protected isTreeItem(node: unknown): node is TreeItem {
+        return isObject<TreeItem>(node) && !!node.resourceUri;
     }
 }