@theia/plugin-ext 1.28.0-next.15 → 1.28.0-next.19

package/src/main/browser/menus/plugin-menu-command-adapter.ts

@@ -0,0 +1,257 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 { CommandRegistry, Disposable, MenuCommandAdapter, MenuPath, SelectionService, UriSelection } from '@theia/core';
+import { ResourceContextKey } from '@theia/core/lib/browser/resource-context-key';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
+import { TreeWidgetSelection } from '@theia/core/lib/browser/tree/tree-widget-selection';
+import { ScmRepository } from '@theia/scm/lib/browser/scm-repository';
+import { ScmService } from '@theia/scm/lib/browser/scm-service';
+import { TimelineItem } from '@theia/timeline/lib/common/timeline-model';
+import { ScmCommandArg, TimelineCommandArg, TreeViewSelection } from '../../../common';
+import { PluginScmProvider, PluginScmResource, PluginScmResourceGroup } from '../scm-main';
+import { TreeViewWidget } from '../view/tree-view-widget';
+import { CodeEditorWidgetUtil, codeToTheiaMappings, ContributionPoint } from './vscode-theia-menu-mappings';
+import { TAB_BAR_TOOLBAR_CONTEXT_MENU } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+
+export type ArgumentAdapter = (...args: unknown[]) => unknown[];
+
+export class ReferenceCountingSet<T> {
+    protected readonly references: Map<T, number>;
+    constructor(initialMembers?: Iterable<T>) {
+        this.references = new Map();
+        if (initialMembers) {
+            for (const member of initialMembers) {
+                this.add(member);
+            }
+        }
+    }
+
+    add(newMember: T): ReferenceCountingSet<T> {
+        const value = this.references.get(newMember) ?? 0;
+        this.references.set(newMember, value + 1);
+        return this;
+    }
+
+    /** @returns true if the deletion results in the removal of the element from the set */
+    delete(member: T): boolean {
+        const value = this.references.get(member);
+        if (value === undefined) { } else if (value <= 1) {
+            this.references.delete(member);
+            return true;
+        } else {
+            this.references.set(member, value - 1);
+        }
+        return false;
+    }
+
+    has(maybeMember: T): boolean {
+        return this.references.has(maybeMember);
+    }
+}
+
+@injectable()
+export class PluginMenuCommandAdapter implements MenuCommandAdapter {
+    @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
+    @inject(CodeEditorWidgetUtil) protected readonly codeEditorUtil: CodeEditorWidgetUtil;
+    @inject(ScmService) protected readonly scmService: ScmService;
+    @inject(SelectionService) protected readonly selectionService: SelectionService;
+    @inject(ResourceContextKey) protected readonly resourceContextKey: ResourceContextKey;
+
+    protected readonly commands = new ReferenceCountingSet<string>();
+    protected readonly argumentAdapters = new Map<string, ArgumentAdapter>();
+    protected readonly separator = ':)(:';
+
+    @postConstruct()
+    protected init(): void {
+        const toCommentArgs: ArgumentAdapter = (...args) => this.toCommentArgs(...args);
+        const firstArgOnly: ArgumentAdapter = (...args) => [args[0]];
+        const noArgs: ArgumentAdapter = () => [];
+        const toScmArgs: ArgumentAdapter = (...args) => this.toScmArgs(...args);
+        const selectedResource = () => this.getSelectedResource();
+        const widgetURI: ArgumentAdapter = widget => this.codeEditorUtil.is(widget) ? [this.codeEditorUtil.getResourceUri(widget)] : [];
+        (<Array<[ContributionPoint, ArgumentAdapter | undefined]>>[
+            ['comments/comment/context', toCommentArgs],
+            ['comments/comment/title', toCommentArgs],
+            ['comments/commentThread/context', toCommentArgs],
+            ['debug/callstack/context', firstArgOnly],
+            ['debug/toolBar', noArgs],
+            ['editor/context', selectedResource],
+            ['editor/title', widgetURI],
+            ['editor/title/context', selectedResource],
+            ['explorer/context', selectedResource],
+            ['scm/resourceFolder/context', toScmArgs],
+            ['scm/resourceGroup/context', toScmArgs],
+            ['scm/resourceState/context', toScmArgs],
+            ['scm/title', () => this.toScmArg(this.scmService.selectedRepository)],
+            ['timeline/item/context', (...args) => this.toTimelineArgs(...args)],
+            ['view/item/context', (...args) => this.toTreeArgs(...args)],
+            ['view/title', noArgs],
+        ]).forEach(([contributionPoint, adapter]) => {
+            if (adapter) {
+                const paths = codeToTheiaMappings.get(contributionPoint);
+                if (paths) {
+                    paths.forEach(([path]) => this.addArgumentAdapter(path, adapter));
+                }
+            }
+        });
+        this.addArgumentAdapter(TAB_BAR_TOOLBAR_CONTEXT_MENU, widgetURI);
+    }
+
+    canHandle(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): number {
+        if (this.commands.has(command) && this.getArgumentAdapterForMenu(menuPath)) {
+            return 500;
+        }
+        return -1;
+    }
+
+    executeCommand(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): Promise<unknown> {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.executeCommand(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isVisible(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isVisible(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isEnabled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isEnabled(command, ...argumentAdapter(...commandArgs));
+    }
+
+    isToggled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        const argumentAdapter = this.getAdapterOrThrow(menuPath);
+        return this.commandRegistry.isToggled(command, ...argumentAdapter(...commandArgs));
+    }
+
+    protected getAdapterOrThrow(menuPath: MenuPath): ArgumentAdapter {
+        const argumentAdapter = this.getArgumentAdapterForMenu(menuPath);
+        if (!argumentAdapter) {
+            throw new Error('PluginMenuCommandAdapter attempted to execute command for unregistered menu: ' + JSON.stringify(menuPath));
+        }
+        return argumentAdapter;
+    }
+
+    addCommand(commandId: string): Disposable {
+        this.commands.add(commandId);
+        return Disposable.create(() => this.commands.delete(commandId));
+    }
+
+    protected getArgumentAdapterForMenu(menuPath: MenuPath): ArgumentAdapter | undefined {
+        return this.argumentAdapters.get(menuPath.join(this.separator));
+    }
+
+    protected addArgumentAdapter(menuPath: MenuPath, adapter: ArgumentAdapter): void {
+        this.argumentAdapters.set(menuPath.join(this.separator), adapter);
+    }
+
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+
+    protected toCommentArgs(...args: any[]): any[] {
+        const arg = args[0];
+        if ('text' in arg) {
+            if ('commentUniqueId' in arg) {
+                return [{
+                    commentControlHandle: arg.thread.controllerHandle,
+                    commentThreadHandle: arg.thread.commentThreadHandle,
+                    text: arg.text,
+                    commentUniqueId: arg.commentUniqueId
+                }];
+            }
+            return [{
+                commentControlHandle: arg.thread.controllerHandle,
+                commentThreadHandle: arg.thread.commentThreadHandle,
+                text: arg.text
+            }];
+        }
+        return [{
+            commentControlHandle: arg.thread.controllerHandle,
+            commentThreadHandle: arg.thread.commentThreadHandle,
+            commentUniqueId: arg.commentUniqueId
+        }];
+    }
+
+    protected toScmArgs(...args: any[]): any[] {
+        const scmArgs: any[] = [];
+        for (const arg of args) {
+            const scmArg = this.toScmArg(arg);
+            if (scmArg) {
+                scmArgs.push(scmArg);
+            }
+        }
+        return scmArgs;
+    }
+
+    protected toScmArg(arg: any): ScmCommandArg | undefined {
+        if (arg instanceof ScmRepository && arg.provider instanceof PluginScmProvider) {
+            return {
+                sourceControlHandle: arg.provider.handle
+            };
+        }
+        if (arg instanceof PluginScmResourceGroup) {
+            return {
+                sourceControlHandle: arg.provider.handle,
+                resourceGroupHandle: arg.handle
+            };
+        }
+        if (arg instanceof PluginScmResource) {
+            return {
+                sourceControlHandle: arg.group.provider.handle,
+                resourceGroupHandle: arg.group.handle,
+                resourceStateHandle: arg.handle
+            };
+        }
+    }
+
+    protected toTimelineArgs(...args: any[]): any[] {
+        const timelineArgs: any[] = [];
+        const arg = args[0];
+        timelineArgs.push(this.toTimelineArg(arg));
+        timelineArgs.push(CodeUri.parse(arg.uri));
+        timelineArgs.push(arg.source ?? '');
+        return timelineArgs;
+    }
+
+    protected toTimelineArg(arg: TimelineItem): TimelineCommandArg {
+        return {
+            timelineHandle: arg.handle,
+            source: arg.source,
+            uri: arg.uri
+        };
+    }
+
+    protected toTreeArgs(...args: any[]): any[] {
+        const treeArgs: any[] = [];
+        for (const arg of args) {
+            if (TreeViewSelection.is(arg)) {
+                treeArgs.push(arg);
+            }
+        }
+        return treeArgs;
+    }
+
+    protected getSelectedResource(): [CodeUri | TreeViewSelection | undefined] {
+        const selection = this.selectionService.selection;
+        if (TreeWidgetSelection.is(selection) && selection.source instanceof TreeViewWidget && selection[0]) {
+            return [selection.source.toTreeViewSelection(selection[0])];
+        }
+        const uri = UriSelection.getUri(selection) ?? this.resourceContextKey.get();
+        return [uri ? uri['codeUri'] : undefined];
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+}

package/src/main/browser/menus/vscode-theia-menu-mappings.ts

@@ -0,0 +1,85 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 { MenuPath } from '@theia/core';
+import { SHELL_TABBAR_CONTEXT_MENU } from '@theia/core/lib/browser';
+import { Navigatable } from '@theia/core/lib/browser/navigatable';
+import { injectable } from '@theia/core/shared/inversify';
+import { URI as CodeUri } from '@theia/core/shared/vscode-uri';
+import { DebugStackFramesWidget } from '@theia/debug/lib/browser/view/debug-stack-frames-widget';
+import { DebugThreadsWidget } from '@theia/debug/lib/browser/view/debug-threads-widget';
+import { EditorWidget, EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
+import { NAVIGATOR_CONTEXT_MENU } from '@theia/navigator/lib/browser/navigator-contribution';
+import { ScmTreeWidget } from '@theia/scm/lib/browser/scm-tree-widget';
+import { TIMELINE_ITEM_CONTEXT_MENU } from '@theia/timeline/lib/browser/timeline-tree-widget';
+import { COMMENT_CONTEXT, COMMENT_THREAD_CONTEXT, COMMENT_TITLE } from '../comments/comment-thread-widget';
+import { VIEW_ITEM_CONTEXT_MENU } from '../view/tree-view-widget';
+import { WebviewWidget } from '../webview/webview';
+
+export const PLUGIN_EDITOR_TITLE_MENU = ['plugin_editor/title'];
+export const PLUGIN_SCM_TITLE_MENU = ['plugin_scm/title'];
+export const PLUGIN_VIEW_TITLE_MENU = ['plugin_view/title'];
+
+export const implementedVSCodeContributionPoints = [
+    'comments/comment/context',
+    'comments/comment/title',
+    'comments/commentThread/context',
+    'debug/callstack/context',
+    'editor/context',
+    'editor/title',
+    'editor/title/context',
+    'explorer/context',
+    'scm/resourceFolder/context',
+    'scm/resourceGroup/context',
+    'scm/resourceState/context',
+    'scm/title',
+    'timeline/item/context',
+    'view/item/context',
+    'view/title'
+] as const;
+
+export type ContributionPoint = (typeof implementedVSCodeContributionPoints)[number];
+
+/** The values are combinations of MenuPath and `when` clause, if any */
+export const codeToTheiaMappings = new Map<ContributionPoint, Array<[MenuPath] | [MenuPath, string]>>([
+    ['comments/comment/context', [[COMMENT_CONTEXT]]],
+    ['comments/comment/title', [[COMMENT_TITLE]]],
+    ['comments/commentThread/context', [[COMMENT_THREAD_CONTEXT]]],
+    ['debug/callstack/context', [[DebugStackFramesWidget.CONTEXT_MENU], [DebugThreadsWidget.CONTEXT_MENU]]],
+    ['editor/context', [[EDITOR_CONTEXT_MENU]]],
+    ['editor/title', [[PLUGIN_EDITOR_TITLE_MENU]]],
+    ['editor/title/context', [[SHELL_TABBAR_CONTEXT_MENU, 'resourceSet']]],
+    ['explorer/context', [[NAVIGATOR_CONTEXT_MENU]]],
+    ['scm/resourceFolder/context', [[ScmTreeWidget.RESOURCE_FOLDER_CONTEXT_MENU]]],
+    ['scm/resourceGroup/context', [[ScmTreeWidget.RESOURCE_GROUP_CONTEXT_MENU]]],
+    ['scm/resourceState/context', [[ScmTreeWidget.RESOURCE_CONTEXT_MENU]]],
+    ['scm/title', [[PLUGIN_SCM_TITLE_MENU]]],
+    ['timeline/item/context', [[TIMELINE_ITEM_CONTEXT_MENU]]],
+    ['view/item/context', [[VIEW_ITEM_CONTEXT_MENU]]],
+    ['view/title', [[PLUGIN_VIEW_TITLE_MENU]]],
+]);
+
+type CodeEditorWidget = EditorWidget | WebviewWidget;
+@injectable()
+export class CodeEditorWidgetUtil {
+    is(arg: unknown): arg is CodeEditorWidget {
+        return arg instanceof EditorWidget || arg instanceof WebviewWidget;
+    }
+    getResourceUri(editor: CodeEditorWidget): CodeUri | undefined {
+        const resourceUri = Navigatable.is(editor) && editor.getResourceUri();
+        return resourceUri ? resourceUri['codeUri'] : undefined;
+    }
+}

package/src/main/browser/plugin-ext-frontend-module.ts

@@ -35,7 +35,7 @@ import { PluginWidget } from './plugin-ext-widget';
 import { PluginFrontendViewContribution } from './plugin-frontend-view-contribution';
 import { PluginExtDeployCommandService } from './plugin-ext-deploy-command';
 import { EditorModelService } from './text-editor-model-service';
-import { CodeEditorWidgetUtil, MenusContributionPointHandler } from './menus/menus-contribution-handler';
+import { MenusContributionPointHandler } from './menus/menus-contribution-handler';
 import { PluginContributionHandler } from './plugin-contribution-handler';
 import { PluginViewRegistry, PLUGIN_VIEW_CONTAINER_FACTORY_ID, PLUGIN_VIEW_FACTORY_ID, PLUGIN_VIEW_DATA_FACTORY_ID } from './view/plugin-view-registry';
 import { TextContentResourceResolver } from './workspace-main';
@@ -78,6 +78,8 @@ import { WebviewFrontendSecurityWarnings } from './webview/webview-frontend-secu
 import { PluginAuthenticationServiceImpl } from './plugin-authentication-service';
 import { AuthenticationService } from '@theia/core/lib/browser/authentication-service';
 import { bindTreeViewDecoratorUtilities, TreeViewDecoratorService } from './view/tree-view-decorator-service';
+import { CodeEditorWidgetUtil } from './menus/vscode-theia-menu-mappings';
+import { PluginMenuCommandAdapter } from './menus/plugin-menu-command-adapter';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -213,6 +215,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(LabelProviderContribution).toService(PluginIconThemeService);
 
     bind(MenusContributionPointHandler).toSelf().inSingletonScope();
+    bind(PluginMenuCommandAdapter).toSelf().inSingletonScope();
     bind(CodeEditorWidgetUtil).toSelf().inSingletonScope();
     bind(KeybindingsContributionPointHandler).toSelf().inSingletonScope();
     bind(PluginContributionHandler).toSelf().inSingletonScope();

package/src/main/browser/plugin-shared-style.ts

@@ -111,7 +111,6 @@ export class PluginSharedStyle {
         const iconClass = 'plugin-icon-' + this.iconSequence++;
         const toDispose = new DisposableCollection();
         toDispose.push(this.insertRule('.' + iconClass, theme => `
-                display: inline-block;
                 background-position: 2px;
                 width: ${size}px;
                 height: ${size}px;

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

@@ -399,14 +399,14 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     protected renderInlineCommand(node: ActionMenuNode, index: number, tabbable: boolean, arg: any): React.ReactNode {
         const { icon } = node;
-        if (!icon || !this.commands.isVisible(node.action.commandId, arg) || !node.action.when || !this.contextKeys.match(node.action.when)) {
+        if (!icon || !this.commands.isVisible(node.command, arg) || !node.when || !this.contextKeys.match(node.when)) {
             return false;
         }
         const className = [TREE_NODE_SEGMENT_CLASS, TREE_NODE_TAIL_CLASS, icon, ACTION_ITEM, 'theia-tree-view-inline-action'].join(' ');
         const tabIndex = tabbable ? 0 : undefined;
         return <div key={index} className={className} title={node.label} tabIndex={tabIndex} onClick={e => {
             e.stopPropagation();
-            this.commands.executeCommand(node.action.commandId, arg);
+            this.commands.executeCommand(node.command, arg);
         }} />;
     }
 

package/src/plugin/languages/signature.ts

@@ -52,6 +52,7 @@ export class SignatureHelpAdapter {
         if (!value) {
             return undefined;
         }
+        value.activeParameter = value.signatures[value.activeSignature].activeParameter ?? value.activeParameter;
         const id = this.idSequence++;
         this.cache.set(id, value);
         return Converter.SignatureHelp.from(id, value);
@@ -65,7 +66,8 @@ export class SignatureHelpAdapter {
             if (saved) {
                 activeSignatureHelp = saved;
                 activeSignatureHelp.activeSignature = revivedSignatureHelp.activeSignature;
-                activeSignatureHelp.activeParameter = revivedSignatureHelp.activeParameter;
+                const { activeSignature } = revivedSignatureHelp;
+                activeSignatureHelp.activeParameter = revivedSignatureHelp.signatures[activeSignature].activeParameter ?? revivedSignatureHelp.activeParameter;
             } else {
                 activeSignatureHelp = revivedSignatureHelp;
             }

package/src/plugin/type-converters.ts

@@ -482,7 +482,8 @@ export namespace SignatureInformation {
         return {
             label: info.label,
             documentation: info.documentation ? fromMarkdown(info.documentation) : undefined,
-            parameters: info.parameters && info.parameters.map(ParameterInformation.from)
+            parameters: info.parameters && info.parameters.map(ParameterInformation.from),
+            activeParameter: info.activeParameter
         };
     }
 
@@ -490,7 +491,8 @@ export namespace SignatureInformation {
         return {
             label: info.label,
             documentation: MarkdownStringDTO.is(info.documentation) ? toMarkdown(info.documentation) : info.documentation,
-            parameters: info.parameters && info.parameters.map(ParameterInformation.to)
+            parameters: info.parameters && info.parameters.map(ParameterInformation.to),
+            activeParameter: info.activeParameter
         };
     }
 }

package/src/plugin/types-impl.ts

@@ -1071,6 +1071,7 @@ export class SignatureInformation {
     label: string;
     documentation?: string | theia.MarkdownString;
     parameters: ParameterInformation[];
+    activeParameter?: number;
 
     constructor(label: string, documentation?: string | theia.MarkdownString) {
         this.label = label;