@theia/plugin-ext 1.33.0 → 1.34.0-next.31

package/src/plugin/tabs.ts

@@ -0,0 +1,430 @@
+// *****************************************************************************
+// Copyright (C) 2022 TypeFox 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 * as theia from '@theia/plugin';
+import { Emitter } from '@theia/core';
+import { RPCProtocol } from '../common/rpc-protocol';
+import { PLUGIN_RPC_CONTEXT, TabDto, TabGroupDto, TabInputKind, TabModelOperationKind, TabOperation, TabsExt, TabsMain } from '../common/plugin-api-rpc';
+import {
+    CustomEditorTabInput,
+    InteractiveWindowInput,
+    NotebookDiffEditorTabInput,
+    NotebookEditorTabInput,
+    TerminalEditorTabInput,
+    TextDiffTabInput,
+    TextMergeTabInput,
+    TextTabInput,
+    URI,
+    WebviewEditorTabInput
+} from './types-impl';
+import { assertIsDefined } from '../common/types';
+import { diffSets } from '../common/collections';
+import { ViewColumn } from './type-converters';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// some code copied and modified from https://github.com/microsoft/vscode/blob/1.71.2/src/vs/workbench/api/common/extHostEditorTabs.ts
+
+type AnyTabInput =
+    TextTabInput |
+    TextDiffTabInput |
+    CustomEditorTabInput |
+    NotebookEditorTabInput |
+    NotebookDiffEditorTabInput |
+    WebviewEditorTabInput |
+    TerminalEditorTabInput |
+    InteractiveWindowInput;
+
+class TabExt {
+    private tabApiObject: theia.Tab | undefined;
+    private tabDto!: TabDto;
+    private input: AnyTabInput | undefined;
+    private parentGroup: TabGroupExt;
+    private readonly activeTabIdGetter: () => string;
+
+    constructor(dto: TabDto, parentGroup: TabGroupExt, activeTabIdGetter: () => string) {
+        this.activeTabIdGetter = activeTabIdGetter;
+        this.parentGroup = parentGroup;
+        this.acceptDtoUpdate(dto);
+    }
+
+    get apiObject(): theia.Tab {
+        if (!this.tabApiObject) {
+            // Don't want to lose reference to parent `this` in the getters
+            const that = this;
+            const obj: theia.Tab = {
+                get isActive(): boolean {
+                    // We use a getter function here to always ensure at most 1 active tab per group and prevent iteration for being required
+                    return that.tabDto.id === that.activeTabIdGetter();
+                },
+                get label(): string {
+                    return that.tabDto.label;
+                },
+                get input(): AnyTabInput | undefined {
+                    return that.input;
+                },
+                get isDirty(): boolean {
+                    return that.tabDto.isDirty;
+                },
+                get isPinned(): boolean {
+                    return that.tabDto.isPinned;
+                },
+                get isPreview(): boolean {
+                    return that.tabDto.isPreview;
+                },
+                get group(): theia.TabGroup {
+                    return that.parentGroup.apiObject;
+                }
+            };
+            this.tabApiObject = Object.freeze<theia.Tab>(obj);
+        }
+        return this.tabApiObject;
+    }
+
+    get tabId(): string {
+        return this.tabDto.id;
+    }
+
+    acceptDtoUpdate(tabDto: TabDto): void {
+        this.tabDto = tabDto;
+        this.input = this.initInput();
+    }
+
+    private initInput(): AnyTabInput | undefined {
+        switch (this.tabDto.input.kind) {
+            case TabInputKind.TextInput:
+                return new TextTabInput(URI.revive(this.tabDto.input.uri));
+            case TabInputKind.TextDiffInput:
+                return new TextDiffTabInput(URI.revive(this.tabDto.input.original), URI.revive(this.tabDto.input.modified));
+            case TabInputKind.TextMergeInput:
+                return new TextMergeTabInput(
+                    URI.revive(this.tabDto.input.base),
+                    URI.revive(this.tabDto.input.input1),
+                    URI.revive(this.tabDto.input.input2),
+                    URI.revive(this.tabDto.input.result));
+            case TabInputKind.CustomEditorInput:
+                return new CustomEditorTabInput(URI.revive(this.tabDto.input.uri), this.tabDto.input.viewType);
+            case TabInputKind.WebviewEditorInput:
+                return new WebviewEditorTabInput(this.tabDto.input.viewType);
+            case TabInputKind.NotebookInput:
+                return new NotebookEditorTabInput(URI.revive(this.tabDto.input.uri), this.tabDto.input.notebookType);
+            case TabInputKind.NotebookDiffInput:
+                return new NotebookDiffEditorTabInput(URI.revive(this.tabDto.input.original), URI.revive(this.tabDto.input.modified), this.tabDto.input.notebookType);
+            case TabInputKind.TerminalEditorInput:
+                return new TerminalEditorTabInput();
+            case TabInputKind.InteractiveEditorInput:
+                return new InteractiveWindowInput(URI.revive(this.tabDto.input.uri), URI.revive(this.tabDto.input.inputBoxUri));
+            default:
+                return undefined;
+        }
+    }
+}
+
+class TabGroupExt {
+
+    private tabGroupApiObject: theia.TabGroup | undefined;
+    private tabGroupDto: TabGroupDto;
+    private tabsArr: TabExt[] = [];
+    private activeTabId: string = '';
+    private activeGroupIdGetter: () => number | undefined;
+
+    constructor(dto: TabGroupDto, activeGroupIdGetter: () => number | undefined) {
+        this.tabGroupDto = dto;
+        this.activeGroupIdGetter = activeGroupIdGetter;
+        // Construct all tabs from the given dto
+        for (const tabDto of dto.tabs) {
+            if (tabDto.isActive) {
+                this.activeTabId = tabDto.id;
+            }
+            this.tabsArr.push(new TabExt(tabDto, this, () => this.getActiveTabId()));
+        }
+    }
+
+    get apiObject(): theia.TabGroup {
+        if (!this.tabGroupApiObject) {
+            // Don't want to lose reference to parent `this` in the getters
+            const that = this;
+            const obj: theia.TabGroup = {
+                get isActive(): boolean {
+                    // We use a getter function here to always ensure at most 1 active group and prevent iteration for being required
+                    return that.tabGroupDto.groupId === that.activeGroupIdGetter();
+                },
+                get viewColumn(): theia.ViewColumn {
+                    return ViewColumn.to(that.tabGroupDto.viewColumn);
+                },
+                get activeTab(): theia.Tab | undefined {
+                    return that.tabsArr.find(tab => tab.tabId === that.activeTabId)?.apiObject;
+                },
+                get tabs(): Readonly<theia.Tab[]> {
+                    return Object.freeze(that.tabsArr.map(tab => tab.apiObject));
+                }
+            };
+            this.tabGroupApiObject = Object.freeze<theia.TabGroup>(obj);
+        }
+        return this.tabGroupApiObject;
+    }
+
+    get groupId(): number {
+        return this.tabGroupDto.groupId;
+    }
+
+    get tabs(): TabExt[] {
+        return this.tabsArr;
+    }
+
+    acceptGroupDtoUpdate(dto: TabGroupDto): void {
+        this.tabGroupDto = dto;
+    }
+
+    acceptTabOperation(operation: TabOperation): TabExt {
+        // In the open case we add the tab to the group
+        if (operation.kind === TabModelOperationKind.TAB_OPEN) {
+            const tab = new TabExt(operation.tabDto, this, () => this.getActiveTabId());
+            // Insert tab at editor index
+            this.tabsArr.splice(operation.index, 0, tab);
+            if (operation.tabDto.isActive) {
+                this.activeTabId = tab.tabId;
+            }
+            return tab;
+        } else if (operation.kind === TabModelOperationKind.TAB_CLOSE) {
+            const tab = this.tabsArr.splice(operation.index, 1)[0];
+            if (!tab) {
+                throw new Error(`Tab close updated received for index ${operation.index} which does not exist`);
+            }
+            if (tab.tabId === this.activeTabId) {
+                this.activeTabId = '';
+            }
+            return tab;
+        } else if (operation.kind === TabModelOperationKind.TAB_MOVE) {
+            if (operation.oldIndex === undefined) {
+                throw new Error('Invalid old index on move IPC');
+            }
+            // Splice to remove at old index and insert at new index === moving the tab
+            const tab = this.tabsArr.splice(operation.oldIndex, 1)[0];
+            if (!tab) {
+                throw new Error(`Tab move updated received for index ${operation.oldIndex} which does not exist`);
+            }
+            this.tabsArr.splice(operation.index, 0, tab);
+            return tab;
+        }
+        const _tab = this.tabsArr.find(extHostTab => extHostTab.tabId === operation.tabDto.id);
+        if (!_tab) {
+            throw new Error('INVALID tab');
+        }
+        if (operation.tabDto.isActive) {
+            this.activeTabId = operation.tabDto.id;
+        } else if (this.activeTabId === operation.tabDto.id && !operation.tabDto.isActive) {
+            // Events aren't guaranteed to be in order so if we receive a dto that matches the active tab id
+            // but isn't active we mark the active tab id as empty. This prevent onDidActiveTabChange from
+            // firing incorrectly
+            this.activeTabId = '';
+        }
+        _tab.acceptDtoUpdate(operation.tabDto);
+        return _tab;
+    }
+
+    // Not a getter since it must be a function to be used as a callback for the tabs
+    getActiveTabId(): string {
+        return this.activeTabId;
+    }
+}
+
+export class TabsExtImpl implements TabsExt {
+    declare readonly _serviceBrand: undefined;
+
+    private readonly proxy: TabsMain;
+    private readonly onDidChangeTabs = new Emitter<theia.TabChangeEvent>();
+    private readonly onDidChangeTabGroups = new Emitter<theia.TabGroupChangeEvent>();
+
+    // Have to use ! because this gets initialized via an RPC proxy
+    private activeGroupId!: number;
+
+    private tabGroupArr: TabGroupExt[] = [];
+
+    private apiObject: theia.TabGroups | undefined;
+
+    constructor(readonly rpc: RPCProtocol) {
+        this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TABS_MAIN);
+    }
+
+    get tabGroups(): theia.TabGroups {
+        if (!this.apiObject) {
+            const that = this;
+            const obj: theia.TabGroups = {
+                // never changes -> simple value
+                onDidChangeTabGroups: that.onDidChangeTabGroups.event,
+                onDidChangeTabs: that.onDidChangeTabs.event,
+                // dynamic -> getters
+                get all(): Readonly<theia.TabGroup[]> {
+                    return Object.freeze(that.tabGroupArr.map(group => group.apiObject));
+                },
+                get activeTabGroup(): theia.TabGroup {
+                    const activeTabGroupId = that.activeGroupId;
+                    const activeTabGroup = assertIsDefined(that.tabGroupArr.find(candidate => candidate.groupId === activeTabGroupId)?.apiObject);
+                    return activeTabGroup;
+                },
+                close: async (tabOrTabGroup: theia.Tab | readonly theia.Tab[] | theia.TabGroup | readonly theia.TabGroup[], preserveFocus?: boolean) => {
+                    const tabsOrTabGroups = Array.isArray(tabOrTabGroup) ? tabOrTabGroup : [tabOrTabGroup];
+                    if (!tabsOrTabGroups.length) {
+                        return true;
+                    }
+                    // Check which type was passed in and call the appropriate close
+                    // Casting is needed as typescript doesn't seem to infer enough from this
+                    if (isTabGroup(tabsOrTabGroups[0])) {
+                        return this._closeGroups(tabsOrTabGroups as theia.TabGroup[], preserveFocus);
+                    } else {
+                        return this._closeTabs(tabsOrTabGroups as theia.Tab[], preserveFocus);
+                    }
+                },
+                // move: async (tab: theia.Tab, viewColumn: ViewColumn, index: number, preserveFocus?: boolean) => {
+                //  const extHostTab = this._findExtHostTabFromApi(tab);
+                //  if (!extHostTab) {
+                //      throw new Error('Invalid tab');
+                //  }
+                //  this._proxy.$moveTab(extHostTab.tabId, index, typeConverters.ViewColumn.from(viewColumn), preserveFocus);
+                //  return;
+                // }
+            };
+            this.apiObject = Object.freeze(obj);
+        }
+        return this.apiObject;
+    }
+
+    $acceptEditorTabModel(tabGroups: TabGroupDto[]): void {
+
+        const groupIdsBefore = new Set(this.tabGroupArr.map(group => group.groupId));
+        const groupIdsAfter = new Set(tabGroups.map(dto => dto.groupId));
+        const diff = diffSets(groupIdsBefore, groupIdsAfter);
+
+        const closed: theia.TabGroup[] = this.tabGroupArr.filter(group => diff.removed.includes(group.groupId)).map(group => group.apiObject);
+        const opened: theia.TabGroup[] = [];
+        const changed: theia.TabGroup[] = [];
+
+        this.tabGroupArr = tabGroups.map(tabGroup => {
+            const group = new TabGroupExt(tabGroup, () => this.activeGroupId);
+            if (diff.added.includes(group.groupId)) {
+                opened.push(group.apiObject);
+            } else {
+                changed.push(group.apiObject);
+            }
+            return group;
+        });
+
+        // Set the active tab group id
+        const activeTabGroupId = assertIsDefined(tabGroups.find(group => group.isActive === true)?.groupId);
+        if (activeTabGroupId !== undefined && this.activeGroupId !== activeTabGroupId) {
+            this.activeGroupId = activeTabGroupId;
+        }
+        this.onDidChangeTabGroups.fire(Object.freeze({ opened, closed, changed }));
+    }
+
+    $acceptTabGroupUpdate(groupDto: TabGroupDto): void {
+        const group = this.tabGroupArr.find(tabGroup => tabGroup.groupId === groupDto.groupId);
+        if (!group) {
+            throw new Error('Update Group IPC call received before group creation.');
+        }
+        group.acceptGroupDtoUpdate(groupDto);
+        if (groupDto.isActive) {
+            this.activeGroupId = groupDto.groupId;
+        }
+        this.onDidChangeTabGroups.fire(Object.freeze({ changed: [group.apiObject], opened: [], closed: [] }));
+    }
+
+    $acceptTabOperation(operation: TabOperation): void {
+        const group = this.tabGroupArr.find(tabGroup => tabGroup.groupId === operation.groupId);
+        if (!group) {
+            throw new Error('Update Tabs IPC call received before group creation.');
+        }
+        const tab = group.acceptTabOperation(operation);
+
+        // Construct the tab change event based on the operation
+        switch (operation.kind) {
+            case TabModelOperationKind.TAB_OPEN:
+                this.onDidChangeTabs.fire(Object.freeze({
+                    opened: [tab.apiObject],
+                    closed: [],
+                    changed: []
+                }));
+                return;
+            case TabModelOperationKind.TAB_CLOSE:
+                this.onDidChangeTabs.fire(Object.freeze({
+                    opened: [],
+                    closed: [tab.apiObject],
+                    changed: []
+                }));
+                return;
+            case TabModelOperationKind.TAB_MOVE:
+            case TabModelOperationKind.TAB_UPDATE:
+                this.onDidChangeTabs.fire(Object.freeze({
+                    opened: [],
+                    closed: [],
+                    changed: [tab.apiObject]
+                }));
+                return;
+        }
+    }
+
+    private _findExtHostTabFromApi(apiTab: theia.Tab): TabExt | undefined {
+        for (const group of this.tabGroupArr) {
+            for (const tab of group.tabs) {
+                if (tab.apiObject === apiTab) {
+                    return tab;
+                }
+            }
+        }
+        return;
+    }
+
+    private _findExtHostTabGroupFromApi(apiTabGroup: theia.TabGroup): TabGroupExt | undefined {
+        return this.tabGroupArr.find(candidate => candidate.apiObject === apiTabGroup);
+    }
+
+    private async _closeTabs(tabs: theia.Tab[], preserveFocus?: boolean): Promise<boolean> {
+        const extHostTabIds: string[] = [];
+        for (const tab of tabs) {
+            const extHostTab = this._findExtHostTabFromApi(tab);
+            if (!extHostTab) {
+                throw new Error('Tab close: Invalid tab not found!');
+            }
+            extHostTabIds.push(extHostTab.tabId);
+        }
+        return this.proxy.$closeTab(extHostTabIds, preserveFocus);
+    }
+
+    private async _closeGroups(groups: theia.TabGroup[], preserveFocus?: boolean): Promise<boolean> {
+        const extHostGroupIds: number[] = [];
+        for (const group of groups) {
+            const extHostGroup = this._findExtHostTabGroupFromApi(group);
+            if (!extHostGroup) {
+                throw new Error('Group close: Invalid group not found!');
+            }
+            extHostGroupIds.push(extHostGroup.groupId);
+        }
+        return this.proxy.$closeGroup(extHostGroupIds, preserveFocus);
+    }
+}
+
+// #region Utils
+function isTabGroup(obj: unknown): obj is theia.TabGroup {
+    const tabGroup = obj as theia.TabGroup;
+    if (tabGroup.tabs !== undefined) {
+        return true;
+    }
+    return false;
+}
+// #endregion

package/src/plugin/terminal-ext.ts

@@ -20,9 +20,25 @@ import { RPCProtocol } from '../common/rpc-protocol';
 import { Event, Emitter } from '@theia/core/lib/common/event';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import * as theia from '@theia/plugin';
-import { Disposable, EnvironmentVariableMutatorType } from './types-impl';
+import { Disposable, EnvironmentVariableMutatorType, ThemeIcon } from './types-impl';
 import { SerializableEnvironmentVariableCollection } from '@theia/terminal/lib/common/base-terminal-protocol';
 import { ProvidedTerminalLink } from '../common/plugin-api-rpc-model';
+import { ThemeIcon as MonacoThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+
+export function getIconUris(iconPath: theia.TerminalOptions['iconPath']): { id: string } | undefined {
+    if (ThemeIcon.is(iconPath)) {
+        return { id: iconPath.id };
+    }
+    return undefined;
+}
+
+export function getIconClass(options: theia.TerminalOptions | theia.ExtensionTerminalOptions): string | undefined {
+    const iconClass = getIconUris(options.iconPath);
+    if (iconClass) {
+        return MonacoThemeIcon.asClassName(iconClass);
+    }
+    return undefined;
+}
 
 /**
  * Provides high level terminal plugin api to use in the Theia plugins.
@@ -65,7 +81,7 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         nameOrOptions: TerminalOptions | PseudoTerminalOptions | ExtensionTerminalOptions | (string | undefined),
         shellPath?: string, shellArgs?: string[] | string
     ): Terminal {
-        let options: TerminalOptions;
+        let options: TerminalOptions | ExtensionTerminalOptions;
         let pseudoTerminal: theia.Pseudoterminal | undefined = undefined;
         const id = `plugin-terminal-${UUID.uuid4()}`;
         if (typeof nameOrOptions === 'object') {
@@ -85,7 +101,22 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
                 shellArgs: shellArgs
             };
         }
-        this.proxy.$createTerminal(id, options, !!pseudoTerminal);
+
+        let parentId;
+
+        if (options.location && typeof options.location === 'object' && 'parentTerminal' in options.location) {
+            const parentTerminal = options.location.parentTerminal;
+            if (parentTerminal instanceof TerminalExtImpl) {
+                for (const [k, v] of this._terminals) {
+                    if (v === parentTerminal) {
+                        parentId = k;
+                        break;
+                    }
+                }
+            }
+        }
+
+        this.proxy.$createTerminal(id, options, parentId, !!pseudoTerminal);
 
         let creationOptions: theia.TerminalOptions | theia.ExtensionTerminalOptions = options;
         // make sure to pass ExtensionTerminalOptions as creation options

package/src/plugin/type-converters.spec.ts

@@ -453,4 +453,24 @@ describe('Type converters:', () => {
             assert.deepStrictEqual(result, showOptions);
         });
     });
+
+    describe('#convertCode', () => {
+        it('should convert a "code" of type "string"', () => {
+            assert.strictEqual(Converter.convertCode('string'), 'string');
+        });
+        it('should convert a "code" of type "number"', () => {
+            assert.strictEqual(Converter.convertCode(4), '4');
+        });
+        it('should convert an undefined "code"', () => {
+            assert.strictEqual(Converter.convertCode(undefined), undefined);
+        });
+        it('should convert a "code" of type "{ value: number, target: Uri }"', () => {
+            const uri = types.URI.parse('foo://example.com:8042/over/there?name=ferret#nose');
+            assert.strictEqual(Converter.convertCode({ value: 4, target: uri }), '4');
+        });
+        it('should convert a "code" of type "{ value: number, target: Uri }"', () => {
+            const uri = types.URI.parse('foo://example.com:8042/over/there?name=ferret#nose');
+            assert.strictEqual(Converter.convertCode({ value: 'string', target: uri }), 'string');
+        });
+    });
 });