@theia/plugin-ext 1.22.0-next.3 → 1.22.0-next.30

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/debug/debug-main.ts

@@ -284,6 +284,17 @@ export class DebugMainImpl implements DebugMain, Disposable {
         return !!session;
     }
 
+    async $stopDebugging(sessionId?: string): Promise<void> {
+        if (sessionId) {
+            const session = this.sessionManager.getSession(sessionId);
+            return this.sessionManager.terminateSession(session);
+        }
+        // Terminate all sessions if no session is provided.
+        for (const session of this.sessionManager.sessions) {
+            this.sessionManager.terminateSession(session);
+        }
+    }
+
     private toTheiaPluginApiBreakpoints(breakpoints: (SourceBreakpoint | FunctionBreakpoint)[]): Breakpoint[] {
         return breakpoints.map(b => this.toTheiaPluginApiBreakpoint(b));
     }

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,14 +36,13 @@ 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';
 import { View } from '../../../common/plugin-protocol';
 import CoreURI from '@theia/core/lib/common/uri';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
-import * as markdownit from 'markdown-it';
+import * as markdownit from '@theia/core/shared/markdown-it';
 import { isMarkdownString } from '../../../plugin/markdown-string';
 
 export const TREE_NODE_HYPERLINK = 'theia-TreeNodeHyperlink';
@@ -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/main/node/plugin-deployer-impl.ts

@@ -21,7 +21,7 @@ import {
     PluginDeployerResolver, PluginDeployerFileHandler, PluginDeployerDirectoryHandler,
     PluginDeployerEntry, PluginDeployer, PluginDeployerParticipant, PluginDeployerStartContext,
     PluginDeployerResolverInit, PluginDeployerFileHandlerContext,
-    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType
+    PluginDeployerDirectoryHandlerContext, PluginDeployerEntryType, PluginDeployerHandler, PluginType, UnresolvedPluginEntry
 } from '../../common/plugin-protocol';
 import { PluginDeployerEntryImpl } from './plugin-deployer-entry-impl';
 import {
@@ -118,11 +118,16 @@ export class PluginDeployerImpl implements PluginDeployer {
         }
 
         const startDeployTime = performance.now();
-        const [userPlugins, systemPlugins] = await Promise.all([
-            this.resolvePlugins(context.userEntries, PluginType.User),
-            this.resolvePlugins(context.systemEntries, PluginType.System)
-        ]);
-        await this.deployPlugins([...userPlugins, ...systemPlugins]);
+        const unresolvedUserEntries = context.userEntries.map(id => ({
+            id,
+            type: PluginType.User
+        }));
+        const unresolvedSystemEntries = context.systemEntries.map(id => ({
+            id,
+            type: PluginType.System
+        }));
+        const plugins = await this.resolvePlugins([...unresolvedUserEntries, ...unresolvedSystemEntries]);
+        await this.deployPlugins(plugins);
         this.logMeasurement('Deploy plugins list', startDeployTime);
     }
 
@@ -132,50 +137,53 @@ export class PluginDeployerImpl implements PluginDeployer {
         }
     }
 
-    async deploy(pluginEntry: string, type: PluginType = PluginType.System): Promise<void> {
+    async deploy(plugin: UnresolvedPluginEntry): Promise<void> {
         const startDeployTime = performance.now();
-        await this.deployMultipleEntries([pluginEntry], type);
+        await this.deployMultipleEntries([plugin]);
         this.logMeasurement('Deploy plugin entry', startDeployTime);
     }
 
-    protected async deployMultipleEntries(pluginEntries: ReadonlyArray<string>, type: PluginType = PluginType.System): Promise<void> {
-        const pluginsToDeploy = await this.resolvePlugins(pluginEntries, type);
+    protected async deployMultipleEntries(plugins: UnresolvedPluginEntry[]): Promise<void> {
+        const pluginsToDeploy = await this.resolvePlugins(plugins);
         await this.deployPlugins(pluginsToDeploy);
     }
 
     /**
      * Resolves plugins for the given type.
      *
-     * One can call it multiple times for different types before triggering a single deploy, i.e.
+     * Only call it a single time before triggering a single deploy to prevent re-resolving of extension dependencies, i.e.
      * ```ts
      * const deployer: PluginDeployer;
-     * deployer.deployPlugins([
-     *     ...await deployer.resolvePlugins(userEntries, PluginType.User),
-     *     ...await deployer.resolvePlugins(systemEntries, PluginType.System)
-     * ]);
+     * deployer.deployPlugins(await deployer.resolvePlugins(allPluginEntries));
      * ```
      */
-    async resolvePlugins(pluginEntries: ReadonlyArray<string>, type: PluginType): Promise<PluginDeployerEntry[]> {
+    async resolvePlugins(plugins: UnresolvedPluginEntry[]): Promise<PluginDeployerEntry[]> {
         const visited = new Set<string>();
         const pluginsToDeploy = new Map<string, PluginDeployerEntry>();
 
-        let queue = [...pluginEntries];
+        let queue: UnresolvedPluginEntry[] = [...plugins];
         while (queue.length) {
-            const dependenciesChunk: Array<Map<string, string>> = [];
-            const workload: string[] = [];
+            const dependenciesChunk: Array<{
+                dependencies: Map<string, string>
+                type: PluginType
+            }> = [];
+            const workload: UnresolvedPluginEntry[] = [];
             while (queue.length) {
                 const current = queue.shift()!;
-                if (visited.has(current)) {
+                if (visited.has(current.id)) {
                     continue;
                 } else {
                     workload.push(current);
                 }
-                visited.add(current);
+                visited.add(current.id);
             }
             queue = [];
-            await Promise.all(workload.map(async current => {
+            await Promise.all(workload.map(async ({ id, type }) => {
+                if (type === undefined) {
+                    type = PluginType.System;
+                }
                 try {
-                    const pluginDeployerEntries = await this.resolvePlugin(current, type);
+                    const pluginDeployerEntries = await this.resolvePlugin(id, type);
                     await this.applyFileHandlers(pluginDeployerEntries);
                     await this.applyDirectoryFileHandlers(pluginDeployerEntries);
                     for (const deployerEntry of pluginDeployerEntries) {
@@ -183,18 +191,21 @@ export class PluginDeployerImpl implements PluginDeployer {
                         if (dependencies && !pluginsToDeploy.has(dependencies.metadata.model.id)) {
                             pluginsToDeploy.set(dependencies.metadata.model.id, deployerEntry);
                             if (dependencies.mapping) {
-                                dependenciesChunk.push(dependencies.mapping);
+                                dependenciesChunk.push({ dependencies: dependencies.mapping, type });
                             }
                         }
                     }
                 } catch (e) {
-                    console.error(`Failed to resolve plugins from '${current}'`, e);
+                    console.error(`Failed to resolve plugins from '${id}'`, e);
                 }
             }));
-            for (const dependencies of dependenciesChunk) {
+            for (const { dependencies, type } of dependenciesChunk) {
                 for (const [dependency, deployableDependency] of dependencies) {
                     if (!pluginsToDeploy.has(dependency)) {
-                        queue.push(deployableDependency);
+                        queue.push({
+                            id: deployableDependency,
+                            type
+                        });
                     }
                 }
             }

package/src/main/node/plugin-server-handler.ts

@@ -18,7 +18,7 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { PluginDeployerImpl } from './plugin-deployer-impl';
 import { PluginsKeyValueStorage } from './plugins-key-value-storage';
-import { PluginServer, PluginDeployer, PluginStorageKind, PluginType } from '../../common/plugin-protocol';
+import { PluginServer, PluginDeployer, PluginStorageKind, PluginType, UnresolvedPluginEntry } from '../../common/plugin-protocol';
 import { KeysToAnyValues, KeysToKeysToAnyValue } from '../../common/types';
 
 @injectable()
@@ -32,10 +32,14 @@ export class PluginServerHandler implements PluginServer {
 
     deploy(pluginEntry: string, arg2?: PluginType | CancellationToken): Promise<void> {
         const type = typeof arg2 === 'number' ? arg2 as PluginType : undefined;
-        return this.doDeploy(pluginEntry, type);
+        return this.doDeploy({
+            id: pluginEntry,
+            type: type ?? PluginType.User
+        });
     }
-    protected doDeploy(pluginEntry: string, type: PluginType = PluginType.User): Promise<void> {
-        return this.pluginDeployer.deploy(pluginEntry, type);
+
+    protected doDeploy(pluginEntry: UnresolvedPluginEntry): Promise<void> {
+        return this.pluginDeployer.deploy(pluginEntry);
     }
 
     undeploy(pluginId: string): Promise<void> {

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/node/debug/debug.ts

@@ -168,6 +168,10 @@ export class DebugExtImpl implements DebugExt {
         return this.proxy.$startDebugging(folder, nameOrConfiguration, options);
     }
 
+    stopDebugging(session?: theia.DebugSession): PromiseLike<void> {
+        return this.proxy.$stopDebugging(session?.id);
+    }
+
     registerDebugAdapterDescriptorFactory(debugType: string, factory: theia.DebugAdapterDescriptorFactory): Disposable {
         if (this.descriptorFactories.has(debugType)) {
             throw new Error(`Descriptor factory for ${debugType} has been already registered`);

package/src/plugin/plugin-context.ts

@@ -784,6 +784,9 @@ export function createAPIFactory(
                 Thenable<boolean> {
                 return debugExt.startDebugging(folder, nameOrConfiguration, options);
             },
+            stopDebugging(session?: theia.DebugSession): Thenable<void> {
+                return debugExt.stopDebugging(session);
+            },
             addBreakpoints(breakpoints: theia.Breakpoint[]): void {
                 debugExt.addBreakpoints(breakpoints);
             },

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);
     }