@theia/plugin-ext 1.22.0-next.2 → 1.22.0-next.23

package/src/main/browser/custom-editors/plugin-custom-editor-registry.ts

@@ -23,14 +23,14 @@ import { CommandRegistry, Emitter, MenuModelRegistry } from '@theia/core';
 import { SelectionService } from '@theia/core/lib/common';
 import { UriAwareCommandHandler } from '@theia/core/lib/common/uri-command-handler';
 import { NavigatorContextMenu } from '@theia/navigator/lib//browser/navigator-contribution';
-import { ApplicationShell, DefaultOpenerService, WidgetManager } from '@theia/core/lib/browser';
+import { ApplicationShell, DefaultOpenerService, WidgetManager, WidgetOpenerOptions } from '@theia/core/lib/browser';
 import { CustomEditorWidget } from './custom-editor-widget';
 
 @injectable()
 export class PluginCustomEditorRegistry {
     private readonly editors = new Map<string, CustomEditor>();
     private readonly pendingEditors = new Set<CustomEditorWidget>();
-    private readonly resolvers = new Map<string, (widget: CustomEditorWidget) => void>();
+    private readonly resolvers = new Map<string, (widget: CustomEditorWidget, options?: WidgetOpenerOptions) => void>();
 
     private readonly onWillOpenCustomEditorEmitter = new Emitter<string>();
     readonly onWillOpenCustomEditor = this.onWillOpenCustomEditorEmitter.event;
@@ -109,22 +109,22 @@ export class PluginCustomEditorRegistry {
             )
         );
         toDispose.push(
-            editorOpenHandler.onDidOpenCustomEditor(widget => this.resolveWidget(widget))
+            editorOpenHandler.onDidOpenCustomEditor(event => this.resolveWidget(event[0], event[1]))
         );
         return toDispose;
     }
 
-    resolveWidget = (widget: CustomEditorWidget) => {
+    resolveWidget = (widget: CustomEditorWidget, options?: WidgetOpenerOptions) => {
         const resolver = this.resolvers.get(widget.viewType);
         if (resolver) {
-            resolver(widget);
+            resolver(widget, options);
         } else {
             this.pendingEditors.add(widget);
             this.onWillOpenCustomEditorEmitter.fire(widget.viewType);
         }
     };
 
-    registerResolver(viewType: string, resolver: (widget: CustomEditorWidget) => void): Disposable {
+    registerResolver(viewType: string, resolver: (widget: CustomEditorWidget, options?: WidgetOpenerOptions) => void): Disposable {
         if (this.resolvers.has(viewType)) {
             throw new Error(`Resolver for ${viewType} already registered`);
         }

package/src/main/browser/dialogs/modal-notification.ts

@@ -20,6 +20,7 @@ import { AbstractDialog } from '@theia/core/lib/browser/dialogs';
 import '../../../../src/main/browser/dialogs/style/modal-notification.css';
 import { MainMessageItem, MainMessageOptions } from '../../../common/plugin-api-rpc';
 import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+import { nls } from '@theia/core/lib/common/nls';
 
 export enum MessageType {
     Error = 'error',
@@ -91,7 +92,7 @@ export class ModalNotification extends AbstractDialog<string | undefined> {
         if (actions.length <= 0) {
             this.appendAcceptButton();
         } else if (!actions.some(action => action.isCloseAffordance === true)) {
-            this.appendCloseButton('Close');
+            this.appendCloseButton(nls.localizeByDefault('Close'));
         }
 
         return messageNode;

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

@@ -52,14 +52,14 @@ export class DialogsMainImpl implements DialogsMain {
             } catch {
                 rootStat = undefined;
             }
-        }
 
-        // Try to use as root the parent folder of existing file URI/non existing URI
-        if (rootStat && !rootStat.isDirectory || !rootStat) {
-            try {
-                rootStat = await this.fileService.resolve(new URI(defaultUri).parent);
-            } catch {
-                rootStat = undefined;
+            // Try to use as root the parent folder of existing file URI/non existing URI
+            if (rootStat && !rootStat.isDirectory || !rootStat) {
+                try {
+                    rootStat = await this.fileService.resolve(new URI(defaultUri).parent);
+                } catch {
+                    rootStat = undefined;
+                }
             }
         }
 

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -242,14 +242,10 @@ export class MenusContributionPointHandler {
     }
 
     protected registerViewTitleAction(location: string, action: Menu): Disposable {
-        return this.registerTitleAction(location, { ...action, when: undefined }, {
+        return this.registerTitleAction(location, action, {
             execute: widget => widget instanceof PluginViewWidget && this.commands.executeCommand(action.command!),
-            isEnabled: widget => widget instanceof PluginViewWidget &&
-                this.viewContextKeys.with({ view: widget.options.viewId }, () =>
-                    this.commands.isEnabled(action.command!) && this.viewContextKeys.match(action.when)),
-            isVisible: widget => widget instanceof PluginViewWidget &&
-                this.viewContextKeys.with({ view: widget.options.viewId }, () =>
-                    this.commands.isVisible(action.command!) && this.viewContextKeys.match(action.when))
+            isEnabled: widget => widget instanceof PluginViewWidget && this.commands.isEnabled(action.command!),
+            isVisible: widget => widget instanceof PluginViewWidget && this.commands.isVisible(action.command!),
         });
     }
 

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

@@ -18,12 +18,12 @@ import { injectable, inject, postConstruct } from '@theia/core/shared/inversify'
 import { Panel, Widget } from '@theia/core/shared/@phosphor/widgets';
 import { MenuModelRegistry } from '@theia/core/lib/common/menu';
 import { CommandRegistry } from '@theia/core/lib/common/command';
-import { ViewContextKeyService } from './view-context-key-service';
 import { StatefulWidget } from '@theia/core/lib/browser/shell/shell-layout-restorer';
 import { Message } from '@theia/core/shared/@phosphor/messaging';
 import { TreeViewWidget } from './tree-view-widget';
 import { DescriptionWidget } from '@theia/core/lib/browser/view-container';
-import { Emitter } from '@theia/core/lib/common';
+import { DisposableCollection, Emitter } from '@theia/core/lib/common';
+import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
 
 @injectable()
 export class PluginViewWidgetIdentifier {
@@ -34,14 +34,16 @@ export class PluginViewWidgetIdentifier {
 @injectable()
 export class PluginViewWidget extends Panel implements StatefulWidget, DescriptionWidget {
 
+    protected readonly toDispose = new DisposableCollection();
+
     @inject(MenuModelRegistry)
     protected readonly menus: MenuModelRegistry;
 
     @inject(CommandRegistry)
     protected readonly commands: CommandRegistry;
 
-    @inject(ViewContextKeyService)
-    protected readonly contextKeys: ViewContextKeyService;
+    @inject(ContextKeyService)
+    protected readonly contextKeyService: ContextKeyService;
 
     @inject(PluginViewWidgetIdentifier)
     readonly options: PluginViewWidgetIdentifier;
@@ -59,6 +61,9 @@ export class PluginViewWidget extends Panel implements StatefulWidget, Descripti
     @postConstruct()
     protected init(): void {
         this.id = this.options.id;
+        const localContext = this.contextKeyService.createScoped(this.node);
+        localContext.setContext('view', this.options.viewId);
+        this.toDispose.push(localContext);
     }
 
     protected onActivateRequest(msg: Message): void {
@@ -148,6 +153,11 @@ export class PluginViewWidget extends Panel implements StatefulWidget, Descripti
         super.insertWidget(index, widget);
         this.updateWidgetMessage();
     }
+
+    dispose(): void {
+        this.toDispose.dispose();
+        super.dispose();
+    }
 }
 export namespace PluginViewWidget {
     export interface State {

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

@@ -36,7 +36,6 @@ import {
 import { MenuPath, MenuModelRegistry, ActionMenuNode } from '@theia/core/lib/common/menu';
 import * as React from '@theia/core/shared/react';
 import { PluginSharedStyle } from '../plugin-shared-style';
-import { ViewContextKeyService } from './view-context-key-service';
 import { ACTION_ITEM, Widget } from '@theia/core/lib/browser/widgets/widget';
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { MessageService } from '@theia/core/lib/common/message-service';
@@ -236,8 +235,8 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     @inject(MenuModelRegistry)
     protected readonly menus: MenuModelRegistry;
 
-    @inject(ViewContextKeyService)
-    protected readonly contextKeys: ViewContextKeyService;
+    @inject(ContextKeyService)
+    protected readonly contextKeys: ContextKeyService;
 
     @inject(TreeViewWidgetIdentifier)
     readonly identifier: TreeViewWidgetIdentifier;
@@ -343,7 +342,7 @@ export class TreeViewWidget extends TreeViewWelcomeWidget {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     protected renderInlineCommand(node: ActionMenuNode, index: number, arg: any): React.ReactNode {
         const { icon } = node;
-        if (!icon || !this.commands.isVisible(node.action.commandId, arg) || !this.contextKeys.match(node.action.when)) {
+        if (!icon || !this.commands.isVisible(node.action.commandId, arg) || !node.action.when || !this.contextKeys.match(node.action.when)) {
             return false;
         }
         const className = [TREE_NODE_SEGMENT_CLASS, TREE_NODE_TAIL_CLASS, icon, ACTION_ITEM, 'theia-tree-view-inline-action'].join(' ');

package/src/main/browser/view/view-context-key-service.ts

@@ -74,18 +74,4 @@ export class ViewContextKeyService {
     match(expression: string | undefined): boolean {
         return !expression || this.contextKeyService.match(expression);
     }
-
-    with<T>(input: { view?: string, viewItem?: string }, cb: () => T): T {
-        const view = this.view.get();
-        const viewItem = this.viewItem.get();
-        this.view.set(input.view);
-        this.viewItem.set(input.viewItem);
-        try {
-            return cb();
-        } finally {
-            this.view.set(view);
-            this.viewItem.set(viewItem);
-        }
-    }
-
 }

package/src/plugin/custom-editors.ts

@@ -29,7 +29,7 @@ import { WebviewImpl, WebviewsExtImpl } from './webviews';
 import { CancellationToken, CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import { WorkspaceExtImpl } from './workspace';
-import * as Converters from './type-converters';
+import { WidgetOpenerOptions } from '@theia/core/lib/browser';
 
 export class CustomEditorsExtImpl implements CustomEditorsExt {
     private readonly proxy: CustomEditorsMain;
@@ -121,7 +121,7 @@ export class CustomEditorsExtImpl implements CustomEditorsExt {
         handler: string,
         viewType: string,
         title: string,
-        position: number,
+        widgetOpenerOptions: WidgetOpenerOptions | undefined,
         options: theia.WebviewPanelOptions & theia.WebviewOptions,
         cancellation: CancellationToken
     ): Promise<void> {
@@ -129,10 +129,9 @@ export class CustomEditorsExtImpl implements CustomEditorsExt {
         if (!entry) {
             throw new Error(`No provider found for '${viewType}'`);
         }
-        const viewColumn = Converters.toViewColumn(position);
         const panel = this.webviewExt.createWebviewPanel(viewType, title, {}, options, entry.plugin, handler);
         const webviewOptions = WebviewImpl.toWebviewOptions(options, this.workspace, entry.plugin);
-        await this.proxy.$createCustomEditorPanel(handler, title, viewColumn, webviewOptions);
+        await this.proxy.$createCustomEditorPanel(handler, title, widgetOpenerOptions, webviewOptions);
 
         const revivedResource = URI.revive(resource);
 

package/src/plugin/types-impl.spec.ts

@@ -14,13 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+import { isWindows } from '@theia/core';
 import * as assert from 'assert';
 import * as types from './types-impl';
 
 describe('API Type Implementations:', () => {
 
     describe('URI:', () => {
-         it('should convert to string', () => {
+        it('should convert to string', () => {
             const uriString = 'scheme://authority.com/foo/bar/zoz?query#fragment';
             const uri = types.URI.parse(uriString);
             // when
@@ -29,5 +30,40 @@ describe('API Type Implementations:', () => {
             // then
             assert.strictEqual(result, uriString);
         });
+
+        // Issue: #10370
+        it('should returns correct path while using joinPath()', () => {
+            if (isWindows) {
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\foo\\bar'), '/file.js').toString(), 'file:///c%3A/foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\foo\\bar\\'), 'file.js').toString(), 'file:///c%3A/foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\foo\\bar\\'), '/file.js').toString(), 'file:///c%3A/foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\'), '/file.js').toString(), 'file:///c%3A/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\'), 'bar/file.js').toString(), 'file:///c%3A/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\foo'), './file.js').toString(), 'file:///c%3A/foo/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('c:\\foo'), '/./file.js').toString(), 'file:///c%3A/foo/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('C:\\foo'), '../file.js').toString(), 'file:///c%3A/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('C:\\foo\\.'), '../file.js').toString(), 'file:///c%3A/file.js');
+            } else {
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/foo/bar'), '/file.js').toString(), 'file:///foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/foo/bar'), 'file.js').toString(), 'file:///foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/foo/bar/'), '/file.js').toString(), 'file:///foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/'), '/file.js').toString(), 'file:///file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/foo/bar'), './file.js').toString(), 'file:///foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/foo/bar'), '/./file.js').toString(), 'file:///foo/bar/file.js');
+                assert.strictEqual(types.URI.joinPath(types.URI.file('/foo/bar'), '../file.js').toString(), 'file:///foo/file.js');
+            }
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar')).toString(), 'foo://a/foo/bar');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar'), '/file.js').toString(), 'foo://a/foo/bar/file.js');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar'), 'file.js').toString(), 'foo://a/foo/bar/file.js');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar/'), '/file.js').toString(), 'foo://a/foo/bar/file.js');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/'), '/file.js').toString(), 'foo://a/file.js');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar/'), './file.js').toString(), 'foo://a/foo/bar/file.js');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar/'), '/./file.js').toString(), 'foo://a/foo/bar/file.js');
+            assert.strictEqual(types.URI.joinPath(types.URI.parse('foo://a/foo/bar/'), '../file.js').toString(), 'foo://a/foo/file.js');
+
+            assert.strictEqual(
+                types.URI.joinPath(types.URI.from({ scheme: 'myScheme', authority: 'authority', path: '/path', query: 'query', fragment: 'fragment' }), '/file.js').toString(),
+                'myScheme://authority/path/file.js?query#fragment');
+        });
     });
 });

package/src/plugin/types-impl.ts

@@ -82,7 +82,7 @@ export class URI extends CodeURI implements theia.Uri {
         if (!uri.path) {
             throw new Error('\'joinPath\' called on URI without path');
         }
-        const newPath = paths.resolve(uri.path, ...pathSegments);
+        const newPath = paths.posix.join(uri.path, ...pathSegments);
         return new URI(uri.scheme, uri.authority, newPath, uri.query, uri.fragment);
     }