@theia/core 1.32.0-next.5 → 1.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/core",
-  "version": "1.32.0-next.5+000988a8c",
+  "version": "1.32.0",
   "description": "Theia is a cloud & desktop IDE framework implemented in TypeScript.",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
@@ -16,8 +16,8 @@
     "@phosphor/signaling": "1",
     "@phosphor/virtualdom": "1",
     "@phosphor/widgets": "1",
-    "@theia/application-package": "1.32.0-next.5+000988a8c",
-    "@theia/request": "1.32.0-next.5+000988a8c",
+    "@theia/application-package": "1.32.0",
+    "@theia/request": "1.32.0",
     "@types/body-parser": "^1.16.4",
     "@types/cookie": "^0.3.3",
     "@types/dompurify": "^2.2.2",
@@ -195,12 +195,12 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.31.0",
-    "@theia/re-exports": "1.31.0",
+    "@theia/ext-scripts": "1.32.0",
+    "@theia/re-exports": "1.32.0",
     "minimist": "^1.2.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "000988a8ca23ef33909748f0bad976836f1d57c4"
+  "gitHead": "789d0148748b4dc9dea398520b5a3dd2998d71ec"
 }

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

@@ -18,7 +18,11 @@ import { injectable } from 'inversify';
 import { Disposable } from '../common';
 import { Emitter, Event } from '../common/event';
 
-export interface ContextKey<T> {
+export type ContextKeyValue = null | undefined | boolean | number | string
+    | Array<null | undefined | boolean | number | string>
+    | Record<string, null | undefined | boolean | number | string>;
+
+export interface ContextKey<T extends ContextKeyValue = ContextKeyValue> {
     set(value: T | undefined): void;
     reset(): void;
     get(): T | undefined;
@@ -38,15 +42,18 @@ export interface ContextKeyChangeEvent {
 }
 
 export const ContextKeyService = Symbol('ContextKeyService');
-export interface ContextKeyService extends Disposable {
-    readonly onDidChange: Event<ContextKeyChangeEvent>;
-
-    createKey<T>(key: string, defaultValue: T | undefined): ContextKey<T>;
 
+export interface ContextMatcher extends Disposable {
     /**
      * Whether the expression is satisfied. If `context` provided, the service will attempt to retrieve a context object associated with that element.
      */
     match(expression: string, context?: HTMLElement): boolean;
+}
+
+export interface ContextKeyService extends ContextMatcher {
+    readonly onDidChange: Event<ContextKeyChangeEvent>;
+
+    createKey<T extends ContextKeyValue>(key: string, defaultValue: T | undefined): ContextKey<T>;
 
     /**
      * @returns a Set of the keys used by the given `expression` or `undefined` if none are used or the expression cannot be parsed.
@@ -54,8 +61,8 @@ export interface ContextKeyService extends Disposable {
     parseKeys(expression: string): Set<string> | undefined;
 
     /**
-     * Creates a temporary context that will use the `values` passed in when evaluating `callback`
-     * `callback` must be synchronous.
+     * Creates a temporary context that will use the `values` passed in when evaluating {@link callback}.
+     * {@link callback | The callback} must be synchronous.
      */
     with<T>(values: Record<string, unknown>, callback: () => T): T;
 
@@ -65,13 +72,19 @@ export interface ContextKeyService extends Disposable {
      */
     createScoped(target: HTMLElement): ScopedValueStore;
 
+    /**
+     * @param overlay values to be used in the new {@link ContextKeyService}. These values will be static.
+     * Creates a child service with a separate context and a set of fixed values to override parent values.
+     */
+    createOverlay(overlay: Iterable<[string, unknown]>): ContextMatcher;
+
     /**
      * Set or modify a value in the service's context.
      */
     setContext(key: string, value: unknown): void;
 }
 
-export type ScopedValueStore = Omit<ContextKeyService, 'onDidChange' | 'match' | 'parseKeys' | 'with'>;
+export type ScopedValueStore = Omit<ContextKeyService, 'onDidChange' | 'match' | 'parseKeys' | 'with' | 'createOverlay'>;
 
 @injectable()
 export class ContextKeyServiceDummyImpl implements ContextKeyService {
@@ -82,7 +95,7 @@ export class ContextKeyServiceDummyImpl implements ContextKeyService {
         this.onDidChangeEmitter.fire(event);
     }
 
-    createKey<T>(key: string, defaultValue: T | undefined): ContextKey<T> {
+    createKey<T extends ContextKeyValue>(key: string, defaultValue: T | undefined): ContextKey<T> {
         return ContextKey.None;
     }
     /**
@@ -114,6 +127,13 @@ export class ContextKeyServiceDummyImpl implements ContextKeyService {
         return this;
     }
 
+    /**
+     * Details should be implemented by an extension, e.g. the monaco extension.
+     */
+    createOverlay(overlay: Iterable<[string, unknown]>): ContextMatcher {
+        return this;
+    }
+
     /**
      * Details should be implemented by an extension, e.g. by the monaco extension.
      */

package/src/browser/context-menu-renderer.ts

@@ -19,6 +19,7 @@
 import { injectable } from 'inversify';
 import { MenuPath } from '../common/menu';
 import { Disposable, DisposableCollection } from '../common/disposable';
+import { ContextMatcher } from './context-key-service';
 
 export interface Coordinate { x: number; y: number; }
 export const Coordinate = Symbol('Coordinate');
@@ -117,5 +118,6 @@ export interface RenderContextMenuOptions {
      * of menu items registered for this item.
      */
     context?: HTMLElement;
+    contextKeyService?: ContextMatcher;
     onHide?: () => void;
 }

package/src/browser/core-preferences.ts

@@ -84,15 +84,15 @@ export const corePreferenceSchema: PreferenceSchema = {
             type: 'string',
             enum: ['classic', 'visible', 'hidden', 'compact'],
             markdownEnumDescriptions: [
-                nls.localizeByDefault('Menu is only hidden in full screen mode.'),
-                nls.localizeByDefault('Menu is always visible even in full screen mode.'),
+                nls.localizeByDefault('Menu is displayed at the top of the window and only hidden in full screen mode.'),
+                nls.localizeByDefault('Menu is always visible at the top of the window even in full screen mode.'),
                 nls.localizeByDefault('Menu is always hidden.'),
                 nls.localizeByDefault('Menu is displayed as a compact button in the sidebar. This value is ignored when `#window.titleBarStyle#` is `native`.')
             ],
             default: 'classic',
             scope: 'application',
             // eslint-disable-next-line max-len
-            markdownDescription: nls.localizeByDefault("Control the visibility of the menu bar. A setting of 'toggle' means that the menu bar is hidden and a single press of the Alt key will show it. By default, the menu bar will be visible, unless the window is full screen."),
+            markdownDescription: nls.localizeByDefault('Control the visibility of the menu bar. A setting of \'toggle\' means that the menu bar is hidden and a single press of the Alt key will show it. A setting of \'compact\' will move the menu into the sidebar.'),
             included: !(isOSX && environment.electron.is())
         },
         'window.title': {
@@ -144,7 +144,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             type: 'boolean',
             default: true,
             // eslint-disable-next-line max-len
-            description: nls.localizeByDefault('Controls whether CA certificates should be loaded from the OS. (On Windows and macOS a reload of the window is required after turning this off.)'),
+            description: nls.localizeByDefault('Controls whether CA certificates should be loaded from the OS. (On Windows and macOS, a reload of the window is required after turning this off.)'),
             scope: 'application'
         },
         'workbench.list.openMode': {
@@ -155,7 +155,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             ],
             default: 'singleClick',
             // eslint-disable-next-line max-len
-            description: nls.localizeByDefault('Controls how to open items in trees and lists using the mouse (if supported). For parents with children in trees, this setting will control if a single click expands the parent or a double click. Note that some trees and lists might choose to ignore this setting if it is not applicable. ')
+            description: nls.localizeByDefault('Controls how to open items in trees and lists using the mouse (if supported). Note that some trees and lists might choose to ignore this setting if it is not applicable.')
         },
         'workbench.editor.highlightModifiedTabs': {
             'type': 'boolean',
@@ -222,19 +222,15 @@ export const corePreferenceSchema: PreferenceSchema = {
             default: 300,
             minimum: 0,
             maximum: 2000,
-            // nls-todo: Will be available with VSCode API 1.55
-            description: nls.localize('theia/core/sashDelay', 'Controls the hover feedback delay in milliseconds of the dragging area in between views/editors.')
+            description: nls.localizeByDefault('Controls the hover feedback delay in milliseconds of the dragging area in between views/editors.')
         },
         'workbench.sash.size': {
             type: 'number',
             default: 4,
             minimum: 1,
             maximum: 20,
-            // nls-todo: Will be available with VSCode API 1.55
-            description: nls.localize(
-                'theia/core/sashSize',
-                'Controls the feedback area size in pixels of the dragging area in between views/editors. Set it to a larger value if needed.'
-            )
+            // eslint-disable-next-line max-len
+            description: nls.localizeByDefault('Controls the feedback area size in pixels of the dragging area in between views/editors. Set it to a larger value if you feel it\'s hard to resize views using the mouse.')
         },
         'workbench.tab.maximize': {
             type: 'boolean',

package/src/browser/frontend-application-module.ts

@@ -135,6 +135,7 @@ import { bindStatusBar } from './status-bar';
 import { MarkdownRenderer, MarkdownRendererFactory, MarkdownRendererImpl } from './markdown-rendering/markdown-renderer';
 import { StylingParticipant, StylingService } from './styling-service';
 import { bindCommonStylingParticipants } from './common-styling-participants';
+import { HoverService } from './hover-service';
 
 export { bindResourceProvider, bindMessageService, bindPreferenceService };
 
@@ -186,7 +187,8 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
         const selectionService = container.get(SelectionService);
         const commandService = container.get<CommandService>(CommandService);
         const corePreferences = container.get<CorePreferences>(CorePreferences);
-        return new TabBarRenderer(contextMenuRenderer, tabBarDecoratorService, iconThemeService, selectionService, commandService, corePreferences);
+        const hoverService = container.get(HoverService);
+        return new TabBarRenderer(contextMenuRenderer, tabBarDecoratorService, iconThemeService, selectionService, commandService, corePreferences, hoverService);
     });
     bind(TheiaDockPanel.Factory).toFactory(({ container }) => options => {
         const corePreferences = container.get<CorePreferences>(CorePreferences);
@@ -433,6 +435,8 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
     bind(SaveResourceService).toSelf().inSingletonScope();
     bind(UserWorkingDirectoryProvider).toSelf().inSingletonScope();
 
+    bind(HoverService).toSelf().inSingletonScope();
+
     bind(StylingService).toSelf().inSingletonScope();
     bindContributionProvider(bind, StylingParticipant);
     bind(FrontendApplicationContribution).toService(StylingService);

package/src/browser/hover-service.ts

@@ -0,0 +1,189 @@
+// *****************************************************************************
+// 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 { inject, injectable } from 'inversify';
+import { Disposable, DisposableCollection, disposableTimeout, isOSX } from '../common';
+import { MarkdownString } from '../common/markdown-rendering/markdown-string';
+import { animationFrame } from './browser';
+import { MarkdownRenderer, MarkdownRendererFactory } from './markdown-rendering/markdown-renderer';
+import { PreferenceService } from './preferences';
+
+import '../../src/browser/style/hover-service.css';
+
+export type HoverPosition = 'left' | 'right' | 'top' | 'bottom';
+
+export namespace HoverPosition {
+    export function invertIfNecessary(position: HoverPosition, target: DOMRect, host: DOMRect, totalWidth: number, totalHeight: number): HoverPosition {
+        if (position === 'left') {
+            if (target.left - host.width - 5 < 0) {
+                return 'right';
+            }
+        } else if (position === 'right') {
+            if (target.right + host.width + 5 > totalWidth) {
+                return 'left';
+            }
+        } else if (position === 'top') {
+            if (target.top - host.height - 5 < 0) {
+                return 'bottom';
+            }
+        } else if (position === 'bottom') {
+            if (target.bottom + host.height + 5 > totalHeight) {
+                return 'top';
+            }
+        }
+        return position;
+    }
+}
+
+export interface HoverRequest {
+    content: string | MarkdownString | HTMLElement
+    target: HTMLElement
+    /**
+     * The position where the hover should appear.
+     * Note that the hover service will try to invert the position (i.e. right -> left)
+     * if the specified content does not fit in the window next to the target element
+     */
+    position: HoverPosition
+}
+
+@injectable()
+export class HoverService {
+    protected static hostClassName = 'theia-hover';
+    protected static styleSheetId = 'theia-hover-style';
+    @inject(PreferenceService) protected readonly preferences: PreferenceService;
+    @inject(MarkdownRendererFactory) protected readonly markdownRendererFactory: MarkdownRendererFactory;
+
+    protected _markdownRenderer: MarkdownRenderer | undefined;
+    protected get markdownRenderer(): MarkdownRenderer {
+        this._markdownRenderer ||= this.markdownRendererFactory();
+        return this._markdownRenderer;
+    }
+
+    protected _hoverHost: HTMLElement | undefined;
+    protected get hoverHost(): HTMLElement {
+        if (!this._hoverHost) {
+            this._hoverHost = document.createElement('div');
+            this._hoverHost.classList.add(HoverService.hostClassName);
+            this._hoverHost.style.position = 'absolute';
+        }
+        return this._hoverHost;
+    }
+    protected pendingTimeout: Disposable | undefined;
+    protected hoverTarget: HTMLElement | undefined;
+    protected lastHidHover = Date.now();
+    protected readonly disposeOnHide = new DisposableCollection();
+
+    requestHover(request: HoverRequest): void {
+        if (request.target !== this.hoverTarget) {
+            this.cancelHover();
+            this.pendingTimeout = disposableTimeout(() => this.renderHover(request), this.getHoverDelay());
+        }
+    }
+
+    protected getHoverDelay(): number {
+        return Date.now() - this.lastHidHover < 200
+            ? 0
+            : this.preferences.get('workbench.hover.delay', isOSX ? 1500 : 500);
+    }
+
+    protected async renderHover(request: HoverRequest): Promise<void> {
+        const host = this.hoverHost;
+        const { target, content, position } = request;
+        this.hoverTarget = target;
+        if (content instanceof HTMLElement) {
+            host.appendChild(content);
+        } else if (typeof content === 'string') {
+            host.textContent = content;
+        } else {
+            const renderedContent = this.markdownRenderer.render(content);
+            this.disposeOnHide.push(renderedContent);
+            host.appendChild(renderedContent.element);
+        }
+        // browsers might insert linebreaks when the hover appears at the edge of the window
+        // resetting the position prevents that
+        host.style.left = '0px';
+        host.style.top = '0px';
+        document.body.append(host);
+        await animationFrame(); // Allow the browser to size the host
+        const updatedPosition = this.setHostPosition(target, host, position);
+
+        this.disposeOnHide.push({
+            dispose: () => {
+                this.lastHidHover = Date.now();
+                host.classList.remove(updatedPosition);
+            }
+        });
+
+        this.listenForMouseOut();
+    }
+
+    protected setHostPosition(target: HTMLElement, host: HTMLElement, position: HoverPosition): HoverPosition {
+        const targetDimensions = target.getBoundingClientRect();
+        const hostDimensions = host.getBoundingClientRect();
+        const documentWidth = document.body.getBoundingClientRect().width;
+        // document.body.getBoundingClientRect().height doesn't work as expected
+        // scrollHeight will always be accurate here: https://stackoverflow.com/a/44077777
+        const documentHeight = document.documentElement.scrollHeight;
+        position = HoverPosition.invertIfNecessary(position, targetDimensions, hostDimensions, documentWidth, documentHeight);
+        if (position === 'top' || position === 'bottom') {
+            const targetMiddleWidth = targetDimensions.left + (targetDimensions.width / 2);
+            const middleAlignment = targetMiddleWidth - (hostDimensions.width / 2);
+            const furthestRight = Math.min(documentWidth - hostDimensions.width, middleAlignment);
+            const left = Math.max(0, furthestRight);
+            const top = position === 'top'
+                ? targetDimensions.top - hostDimensions.height - 5
+                : targetDimensions.bottom + 5;
+            host.style.setProperty('--theia-hover-before-position', `${targetMiddleWidth - left - 5}px`);
+            host.style.top = `${top}px`;
+            host.style.left = `${left}px`;
+        } else {
+            const targetMiddleHeight = targetDimensions.top + (targetDimensions.height / 2);
+            const middleAlignment = targetMiddleHeight - (hostDimensions.height / 2);
+            const furthestTop = Math.min(documentHeight - hostDimensions.height, middleAlignment);
+            const top = Math.max(0, furthestTop);
+            const left = position === 'left'
+                ? targetDimensions.left - hostDimensions.width - 5
+                : targetDimensions.right + 5;
+            host.style.setProperty('--theia-hover-before-position', `${targetMiddleHeight - top - 5}px`);
+            host.style.left = `${left}px`;
+            host.style.top = `${top}px`;
+        }
+        host.classList.add(position);
+        return position;
+    }
+
+    protected listenForMouseOut(): void {
+        const handleMouseMove = (e: MouseEvent) => {
+            if (e.target instanceof Node && !this.hoverHost.contains(e.target) && !this.hoverTarget?.contains(e.target)) {
+                this.cancelHover();
+            }
+        };
+        document.addEventListener('mousemove', handleMouseMove);
+        this.disposeOnHide.push({ dispose: () => document.removeEventListener('mousemove', handleMouseMove) });
+    }
+
+    cancelHover(): void {
+        this.pendingTimeout?.dispose();
+        this.unRenderHover();
+        this.disposeOnHide.dispose();
+        this.hoverTarget = undefined;
+    }
+
+    protected unRenderHover(): void {
+        this.hoverHost.remove();
+        this.hoverHost.replaceChildren();
+    }
+}

package/src/browser/icon-theme-service.ts

@@ -67,7 +67,7 @@ export class NoneIconTheme implements IconTheme, LabelProviderContribution {
         if (this.toDeactivate.disposed) {
             return 0;
         }
-        return Number.MAX_SAFE_INTEGER;
+        return Number.MAX_SAFE_INTEGER - 1024;
     }
 
     getIcon(): string {

package/src/browser/index.ts

@@ -43,3 +43,4 @@ export * from './breadcrumbs';
 export * from './tooltip-service';
 export * from './decoration-style';
 export * from './styling-service';
+export * from './hover-service';

package/src/browser/menu/browser-context-menu-renderer.ts

@@ -34,8 +34,8 @@ export class BrowserContextMenuRenderer extends ContextMenuRenderer {
         super();
     }
 
-    protected doRender({ menuPath, anchor, args, onHide, context }: RenderContextMenuOptions): ContextMenuAccess {
-        const contextMenu = this.menuFactory.createContextMenu(menuPath, args, context);
+    protected doRender({ menuPath, anchor, args, onHide, context, contextKeyService }: RenderContextMenuOptions): ContextMenuAccess {
+        const contextMenu = this.menuFactory.createContextMenu(menuPath, args, context, contextKeyService);
         const { x, y } = coordinateFromAnchor(anchor);
         if (onHide) {
             contextMenu.aboutToClose.connect(() => onHide!());

package/src/browser/menu/browser-menu-plugin.ts

@@ -23,7 +23,7 @@ import {
 } from '../../common';
 import { KeybindingRegistry } from '../keybinding';
 import { FrontendApplicationContribution, FrontendApplication } from '../frontend-application';
-import { ContextKeyService } from '../context-key-service';
+import { ContextKeyService, ContextMatcher } from '../context-key-service';
 import { ContextMenuContext } from './context-menu-context';
 import { waitForRevealed } from '../widgets';
 import { ApplicationShell } from '../shell';
@@ -38,6 +38,7 @@ export abstract class MenuBarWidget extends MenuBar {
 export interface BrowserMenuOptions extends MenuWidget.IOptions {
     commands: MenuCommandRegistry,
     context?: HTMLElement,
+    contextKeyService?: ContextMatcher;
     rootMenuPath: MenuPath
 };
 
@@ -107,10 +108,10 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
         }
     }
 
-    createContextMenu(path: MenuPath, args?: unknown[], context?: HTMLElement): MenuWidget {
+    createContextMenu(path: MenuPath, args?: unknown[], context?: HTMLElement, contextKeyService?: ContextMatcher): MenuWidget {
         const menuModel = this.menuProvider.getMenu(path);
         const menuCommandRegistry = this.createMenuCommandRegistry(menuModel, args).snapshot(path);
-        const contextMenu = this.createMenuWidget(menuModel, { commands: menuCommandRegistry, context, rootMenuPath: path });
+        const contextMenu = this.createMenuWidget(menuModel, { commands: menuCommandRegistry, context, rootMenuPath: path, contextKeyService });
         return contextMenu;
     }
 
@@ -286,7 +287,9 @@ export class DynamicMenuWidget extends MenuWidget {
     }
 
     protected buildSubMenus(parentItems: MenuWidget.IItemOptions[], menu: MenuNode, commands: MenuCommandRegistry): MenuWidget.IItemOptions[] {
-        if (CompoundMenuNode.is(menu) && menu.children.length && this.undefinedOrMatch(menu.when, this.options.context)) {
+        if (CompoundMenuNode.is(menu)
+            && menu.children.length
+            && this.undefinedOrMatch(this.options.contextKeyService ?? this.services.contextKeyService, menu.when, this.options.context)) {
             const role = menu === this.menu ? CompoundMenuNodeRole.Group : CompoundMenuNode.getRole(menu);
             if (role === CompoundMenuNodeRole.Submenu) {
                 const submenu = this.services.menuWidgetFactory.createMenuWidget(menu, this.options);
@@ -307,7 +310,7 @@ export class DynamicMenuWidget extends MenuWidget {
             }
         } else if (menu.command) {
             const node = menu.altNode && this.services.context.altPressed ? menu.altNode : (menu as MenuNode & CommandMenuNode);
-            if (commands.isVisible(node.command) && this.undefinedOrMatch(node.when, this.options.context)) {
+            if (commands.isVisible(node.command) && this.undefinedOrMatch(this.options.contextKeyService ?? this.services.contextKeyService, node.when, this.options.context)) {
                 parentItems.push({
                     command: node.command,
                     type: 'command'
@@ -317,8 +320,8 @@ export class DynamicMenuWidget extends MenuWidget {
         return parentItems;
     }
 
-    protected undefinedOrMatch(expression?: string, context?: HTMLElement): boolean {
-        if (expression) { return this.services.contextKeyService.match(expression, context); }
+    protected undefinedOrMatch(contextKeyService: ContextMatcher, expression?: string, context?: HTMLElement): boolean {
+        if (expression) { return contextKeyService.match(expression, context); }
         return true;
     }
 

package/src/browser/resource-context-key.ts

@@ -16,7 +16,6 @@
 
 import { injectable, inject, postConstruct } from 'inversify';
 import URI from '../common/uri';
-import { URI as Uri } from 'vscode-uri';
 import { ContextKeyService, ContextKey } from './context-key-service';
 import { LanguageService } from './language-service';
 
@@ -29,7 +28,7 @@ export class ResourceContextKey {
     @inject(ContextKeyService)
     protected readonly contextKeyService: ContextKeyService;
 
-    protected resource: ContextKey<Uri>;
+    protected resource: ContextKey<string>;
     protected resourceSchemeKey: ContextKey<string>;
     protected resourceFileName: ContextKey<string>;
     protected resourceExtname: ContextKey<string>;
@@ -40,7 +39,7 @@ export class ResourceContextKey {
 
     @postConstruct()
     protected init(): void {
-        this.resource = this.contextKeyService.createKey<Uri>('resource', undefined);
+        this.resource = this.contextKeyService.createKey<string>('resource', undefined);
         this.resourceSchemeKey = this.contextKeyService.createKey<string>('resourceScheme', undefined);
         this.resourceFileName = this.contextKeyService.createKey<string>('resourceFilename', undefined);
         this.resourceExtname = this.contextKeyService.createKey<string>('resourceExtname', undefined);
@@ -50,13 +49,12 @@ export class ResourceContextKey {
         this.resourceSet = this.contextKeyService.createKey<boolean>('resourceSet', false);
     }
 
-    get(): URI | undefined {
-        const codeUri = this.resource.get();
-        return codeUri && new URI(codeUri);
+    get(): string | undefined {
+        return this.resource.get();
     }
 
     set(resourceUri: URI | undefined): void {
-        this.resource.set(resourceUri?.['codeUri']);
+        this.resource.set(resourceUri?.toString());
         this.resourceSchemeKey.set(resourceUri?.scheme);
         this.resourceFileName.set(resourceUri?.path.base);
         this.resourceExtname.set(resourceUri?.path.ext);

package/src/browser/shell/application-shell.ts

@@ -309,8 +309,8 @@ export class ApplicationShell extends Widget {
     }
 
     protected initFocusKeyContexts(): void {
-        const sideBarFocus = this.contextKeyService.createKey('sideBarFocus', false);
-        const panelFocus = this.contextKeyService.createKey('panelFocus', false);
+        const sideBarFocus = this.contextKeyService.createKey<boolean>('sideBarFocus', false);
+        const panelFocus = this.contextKeyService.createKey<boolean>('panelFocus', false);
         const updateFocusContextKeys = () => {
             const area = this.activeWidget && this.getAreaFor(this.activeWidget);
             sideBarFocus.set(area === 'left');
@@ -1849,6 +1849,13 @@ export class ApplicationShell extends Widget {
                     }
                     return true;
                 } else if (ci === 0) {
+                    if (current && current.titles.length > 0) {
+                        current.currentIndex = current.titles.length - 1;
+                        if (current.currentTitle) {
+                            this.activateWidget(current.currentTitle.owner.id);
+                        }
+                        return true;
+                    }
                     return this.activatePreviousTabBar(current);
                 }
             }