@theia/core 1.30.0-next.7 → 1.30.0

package/src/browser/label-provider.ts

@@ -68,6 +68,11 @@ export interface LabelProviderContribution {
      */
     getLongName?(element: object): string | undefined;
 
+    /**
+     * A compromise between {@link getName} and {@link getLongName}. Can be used to supplement getName in contexts that allow both a primary display field and extra detail.
+     */
+    getDetails?(element: object): string | undefined;
+
     /**
      * Emit when something has changed that may result in this label provider returning a different
      * value for one or more properties (name, icon etc).
@@ -168,6 +173,14 @@ export class DefaultUriLabelProviderContribution implements LabelProviderContrib
         return uri && uri.path.fsPath();
     }
 
+    getDetails(element: URI | URIIconReference): string | undefined {
+        const uri = this.getUri(element);
+        if (uri) {
+            return this.getLongName(uri.parent);
+        }
+        return this.getLongName(element);
+    }
+
     protected getUri(element: URI | URIIconReference): URI | undefined {
         return URIIconReference.is(element) ? element.uri : element;
     }
@@ -325,15 +338,7 @@ export class LabelProvider implements FrontendApplicationContribution {
      * @return the icon class
      */
     getIcon(element: object): string {
-        const contributions = this.findContribution(element);
-        for (const contribution of contributions) {
-            const value = contribution.getIcon && contribution.getIcon(element);
-            if (value === undefined) {
-                continue;
-            }
-            return value;
-        }
-        return '';
+        return this.handleRequest(element, 'getIcon') ?? '';
     }
 
     /**
@@ -341,15 +346,7 @@ export class LabelProvider implements FrontendApplicationContribution {
      * @return the short name
      */
     getName(element: object): string {
-        const contributions = this.findContribution(element);
-        for (const contribution of contributions) {
-            const value = contribution.getName && contribution.getName(element);
-            if (value === undefined) {
-                continue;
-            }
-            return value;
-        }
-        return '<unknown>';
+        return this.handleRequest(element, 'getName') ?? '<unknown>';
     }
 
     /**
@@ -357,21 +354,33 @@ export class LabelProvider implements FrontendApplicationContribution {
      * @return the long name
      */
     getLongName(element: object): string {
-        const contributions = this.findContribution(element);
-        for (const contribution of contributions) {
-            const value = contribution.getLongName && contribution.getLongName(element);
-            if (value === undefined) {
-                continue;
+        return this.handleRequest(element, 'getLongName') ?? '';
+    }
+
+    /**
+     * Get details from the list of available {@link LabelProviderContribution} for the given element.
+     * @return the details
+     * Can be used to supplement {@link getName} in contexts that allow both a primary display field and extra detail.
+     */
+    getDetails(element: object): string {
+        return this.handleRequest(element, 'getDetails') ?? '';
+    }
+
+    protected handleRequest(element: object, method: keyof Omit<LabelProviderContribution, 'canHandle' | 'onDidChange' | 'affects'>): string | undefined {
+        for (const contribution of this.findContribution(element, method)) {
+            const value = contribution[method]?.(element);
+            if (value !== undefined) {
+                return value;
             }
-            return value;
         }
-        return '';
     }
 
-    protected findContribution(element: object): LabelProviderContribution[] {
-        const prioritized = Prioritizeable.prioritizeAllSync(this.contributionProvider.getContributions(), contrib =>
+    protected findContribution(element: object, method?: keyof Omit<LabelProviderContribution, 'canHandle' | 'onDidChange' | 'affects'>): LabelProviderContribution[] {
+        const candidates = method
+            ? this.contributionProvider.getContributions().filter(candidate => candidate[method])
+            : this.contributionProvider.getContributions();
+        return Prioritizeable.prioritizeAllSync(candidates, contrib =>
             contrib.canHandle(element)
-        );
-        return prioritized.map(c => c.value);
+        ).map(entry => entry.value);
     }
 }

package/src/browser/preferences/preference-contribution.ts

@@ -356,6 +356,15 @@ export class PreferenceSchemaProvider extends PreferenceProvider {
         return [][Symbol.iterator]();
     }
 
+    getSchemaProperty(key: string): PreferenceDataProperty | undefined {
+        return this.combinedSchema.properties[key];
+    }
+
+    updateSchemaProperty(key: string, property: PreferenceDataProperty): void {
+        this.updateSchemaProps(key, property);
+        this.fireDidPreferenceSchemaChanged();
+    }
+
     protected updateSchemaProps(key: string, property: PreferenceDataProperty): void {
         this.combinedSchema.properties[key] = property;
 

package/src/browser/preloader.ts

@@ -58,7 +58,10 @@ async function loadBackendOS(): Promise<void> {
 }
 
 function initBackground(): void {
-    const value = window.localStorage.getItem(DEFAULT_BACKGROUND_COLOR_STORAGE_KEY) || '#1d1d1d';
+    // The default light background color is based on the `colors#editor.background` value from
+    // `packages/monaco/data/monaco-themes/vscode/dark_vs.json` and the dark background comes from the `light_vs.json`.
+    const dark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+    const value = window.localStorage.getItem(DEFAULT_BACKGROUND_COLOR_STORAGE_KEY) || (dark ? '#1E1E1E' : '#FFFFFF');
     const documentElement = document.documentElement;
     documentElement.style.setProperty('--theia-editor-background', value);
 }

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

@@ -1957,6 +1957,15 @@ export namespace ApplicationShell {
      */
     export type Area = 'main' | 'top' | 'left' | 'right' | 'bottom' | 'secondaryWindow';
 
+    export const areaLabels: Record<Area, string> = {
+        main: nls.localizeByDefault('Main'),
+        top: nls.localize('theia/shell-area/top', 'Top'),
+        left: nls.localize('theia/shell-area/left', 'Left'),
+        right: nls.localize('theia/shell-area/right', 'Right'),
+        bottom: nls.localize('theia/shell-area/bottom', 'Bottom'),
+        secondaryWindow: nls.localize('theia/shell-area/secondary', 'Secondary Window'),
+    };
+
     /**
      * The _side areas_ are those shell areas that can be collapsed and expanded,
      * i.e. `left`, `right`, and `bottom`.

package/src/browser/shell/tab-bars.ts

@@ -141,11 +141,12 @@ export class TabBarRenderer extends TabBar.Renderer {
      * Render tabs with the default DOM structure, but additionally register a context menu listener.
      * @param {SideBarRenderData} data Data used to render the tab.
      * @param {boolean} isInSidePanel An optional check which determines if the tab is in the side-panel.
+     * @param {boolean} isPartOfHiddenTabBar An optional check which determines if the tab is in the hidden horizontal tab bar.
      * @returns {VirtualElement} The virtual element of the rendered tab.
      */
-    override renderTab(data: SideBarRenderData, isInSidePanel?: boolean): VirtualElement {
+    override renderTab(data: SideBarRenderData, isInSidePanel?: boolean, isPartOfHiddenTabBar?: boolean): VirtualElement {
         const title = data.title;
-        const id = this.createTabId(data.title);
+        const id = this.createTabId(data.title, isPartOfHiddenTabBar);
         const key = this.createTabKey(data);
         const style = this.createTabStyle(data);
         const className = this.createTabClass(data);
@@ -177,8 +178,15 @@ export class TabBarRenderer extends TabBar.Renderer {
         );
     }
 
-    createTabId(title: Title<Widget>): string {
-        return 'shell-tab-' + title.owner.id;
+    /**
+     * Generate ID for an entry in the tab bar
+     * @param {Title<Widget>} title Title of the widget controlled by this tab bar
+     * @param {boolean} isPartOfHiddenTabBar Tells us if this entry is part of the hidden horizontal tab bar.
+     *      If yes, add a suffix to differentiate it's ID from the entry in the visible tab bar
+     * @returns {string} DOM element ID
+     */
+    createTabId(title: Title<Widget>, isPartOfHiddenTabBar = false): string {
+        return 'shell-tab-' + title.owner.id + (isPartOfHiddenTabBar ? '-hidden' : '');
     }
 
     /**
@@ -904,7 +912,8 @@ export class SideTabBar extends ScrollableTabBar {
             } else {
                 rd = { title, current, zIndex };
             }
-            content[i] = renderer.renderTab(rd, true);
+            // Based on how renderTabs() is called, assume renderData will be undefined when invoked for this.hiddenContentNode
+            content[i] = renderer.renderTab(rd, true, renderData === undefined);
         }
         VirtualDOM.render(content, host);
     }

package/src/browser/shell/theia-dock-panel.ts

@@ -20,7 +20,7 @@ import { Signal } from '@phosphor/signaling';
 import { Disposable, DisposableCollection } from '../../common/disposable';
 import { UnsafeWidgetUtilities } from '../widgets';
 import { CorePreferences } from '../core-preferences';
-import { Emitter, environment } from '../../common';
+import { Emitter, Event, environment } from '../../common';
 
 export const MAXIMIZED_CLASS = 'theia-maximized';
 export const ACTIVE_TABBAR_CLASS = 'theia-tabBar-active';
@@ -50,6 +50,10 @@ export class TheiaDockPanel extends DockPanel {
 
     protected readonly onDidToggleMaximizedEmitter = new Emitter<Widget>();
     readonly onDidToggleMaximized = this.onDidToggleMaximizedEmitter.event;
+    protected readonly onDidChangeCurrentEmitter = new Emitter<Title<Widget> | undefined>();
+    get onDidChangeCurrent(): Event<Title<Widget> | undefined> {
+        return this.onDidChangeCurrentEmitter.event;
+    }
 
     constructor(options?: DockPanel.IOptions,
         protected readonly preferences?: CorePreferences
@@ -114,6 +118,7 @@ export class TheiaDockPanel extends DockPanel {
                 title.owner.disposed.disconnect(resetCurrent)
             ));
         }
+        this.onDidChangeCurrentEmitter.fire(title);
     }
 
     markActiveTabBar(title?: Title<Widget>): void {

package/src/browser/style/about.css

@@ -14,14 +14,23 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
- ul.theia-aboutDialog {
+.theia-aboutDialog .about-details {
+    padding-left: 10px;
+}
+
+.theia-aboutDialog .about-details a {
+    cursor: pointer;
+}
+
+ul.theia-aboutDialog {
     flex: 1 100%;
     padding-bottom: calc(var(--theia-ui-padding) * 3);
- }
- ul.theia-aboutExtensions {
+}
+
+ul.theia-aboutExtensions {
     height: 200px;
     overflow: hidden;
     overflow-y: scroll;
     list-style-type: none;
     padding: 0;
- }
+}

package/src/browser/theming.ts

@@ -17,11 +17,12 @@
 import { Emitter, Event } from '../common/event';
 import { Disposable } from '../common/disposable';
 import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
-import { ApplicationProps } from '@theia/application-package/lib/application-props';
+import { ApplicationProps, DefaultTheme } from '@theia/application-package/lib/application-props';
 import { Theme, ThemeChangeEvent } from '../common/theme';
 import { inject, injectable, postConstruct } from 'inversify';
 import { Deferred } from '../common/promise-util';
-import { PreferenceService } from './preferences';
+import { PreferenceSchemaProvider, PreferenceService } from './preferences';
+import debounce = require('lodash.debounce');
 
 const COLOR_THEME_PREFERENCE_KEY = 'workbench.colorTheme';
 const NO_THEME = { id: 'no-theme', label: 'Not a real theme.', type: 'dark' } as const;
@@ -31,6 +32,7 @@ export class ThemeService {
     static readonly STORAGE_KEY = 'theme';
 
     @inject(PreferenceService) protected readonly preferences: PreferenceService;
+    @inject(PreferenceSchemaProvider) protected readonly schemaProvider: PreferenceSchemaProvider;
 
     protected themes: { [id: string]: Theme } = {};
     protected activeTheme: Theme = NO_THEME;
@@ -48,6 +50,7 @@ export class ThemeService {
         this.loadUserTheme();
         this.preferences.ready.then(() => {
             this.validateActiveTheme();
+            this.updateColorThemePreference();
             this.preferences.onPreferencesChanged(changes => {
                 if (COLOR_THEME_PREFERENCE_KEY in changes) {
                     this.validateActiveTheme();
@@ -61,6 +64,7 @@ export class ThemeService {
             this.themes[theme.id] = theme;
         }
         this.validateActiveTheme();
+        this.updateColorThemePreference();
         return Disposable.create(() => {
             for (const theme of themes) {
                 delete this.themes[theme.id];
@@ -68,6 +72,7 @@ export class ThemeService {
                     this.setCurrentTheme(this.defaultTheme.id, false);
                 }
             }
+            this.updateColorThemePreference();
         });
     }
 
@@ -80,6 +85,18 @@ export class ThemeService {
         }
     }
 
+    protected updateColorThemePreference = debounce(() => this.doUpdateColorThemePreference(), 500);
+
+    protected doUpdateColorThemePreference(): void {
+        const preference = this.schemaProvider.getSchemaProperty(COLOR_THEME_PREFERENCE_KEY);
+        if (preference) {
+            const sortedThemes = this.getThemes().sort((a, b) => a.label.localeCompare(b.label));
+            preference.enum = sortedThemes.map(e => e.id);
+            preference.enumItemLabels = sortedThemes.map(e => e.label);
+            this.schemaProvider.updateSchemaProperty(COLOR_THEME_PREFERENCE_KEY, preference);
+        }
+    }
+
     getThemes(): Theme[] {
         const result = [];
         for (const o in this.themes) {
@@ -136,7 +153,8 @@ export class ThemeService {
      * The default theme. If that is not applicable, returns with the fallback theme.
      */
     get defaultTheme(): Theme {
-        return this.tryGetTheme(FrontendApplicationConfigProvider.get().defaultTheme) ?? this.getTheme(ApplicationProps.DEFAULT.frontend.config.defaultTheme);
+        return this.tryGetTheme(DefaultTheme.defaultForOSTheme(FrontendApplicationConfigProvider.get().defaultTheme))
+            ?? this.getTheme(DefaultTheme.defaultForOSTheme(ApplicationProps.DEFAULT.frontend.config.defaultTheme));
     }
 
     /**

package/src/browser/view-container.ts

@@ -30,7 +30,7 @@ import { FrontendApplicationStateService } from './frontend-application-state';
 import { ContextMenuRenderer, Anchor } from './context-menu-renderer';
 import { parseCssMagnitude } from './browser';
 import { TabBarToolbarRegistry, TabBarToolbarFactory, TabBarToolbar, TabBarDelegator, TabBarToolbarItem } from './shell/tab-bar-toolbar';
-import { isEmpty } from '../common';
+import { isEmpty, nls } from '../common';
 import { WidgetManager } from './widget-manager';
 import { Key } from './keys';
 import { ProgressBarFactory } from './progress-bar-factory';
@@ -175,7 +175,7 @@ export class ViewContainer extends BaseWidget implements StatefulWidget, Applica
             }),
             menuRegistry.registerMenuAction([...this.contextMenuPath, '0_global'], {
                 commandId: this.globalHideCommandId,
-                label: 'Hide'
+                label: nls.localize('theia/core/hideViewContainer', 'Hide')
             }),
             this.onDidChangeTrackableWidgetsEmitter,
             this.onDidChangeTrackableWidgets(() => this.decoratorService.fireDidChangeDecorations())

package/src/browser/window/window-title-service.ts

@@ -0,0 +1,107 @@
+// *****************************************************************************
+// Copyright (C) 2022 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, postConstruct } from 'inversify';
+import { escapeRegExpCharacters } from '../../common/strings';
+import { Emitter, Event } from '../../common/event';
+import { CorePreferences } from '../core-preferences';
+import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+
+export const InitialWindowTitleParts = {
+    activeEditorShort: undefined,
+    activeEditorMedium: undefined,
+    activeEditorLong: undefined,
+    activeFolderShort: undefined,
+    activeFolderMedium: undefined,
+    activeFolderLong: undefined,
+    folderName: undefined,
+    folderPath: undefined,
+    rootName: undefined,
+    rootPath: undefined,
+    appName: FrontendApplicationConfigProvider.get().applicationName,
+    remoteName: undefined,
+    dirty: undefined,
+    developmentHost: undefined
+};
+
+@injectable()
+export class WindowTitleService {
+
+    @inject(CorePreferences)
+    protected readonly preferences: CorePreferences;
+
+    protected _title = '';
+    protected titleTemplate?: string;
+
+    protected onDidChangeTitleEmitter = new Emitter<string>();
+    protected titleParts = new Map<string, string | undefined>(Object.entries(InitialWindowTitleParts));
+    protected separator = ' - ';
+
+    @postConstruct()
+    protected init(): void {
+        this.titleTemplate = this.preferences['window.title'];
+        this.separator = this.preferences['window.titleSeparator'];
+        this.updateTitle();
+        this.preferences.onPreferenceChanged(e => {
+            if (e.preferenceName === 'window.title') {
+                this.titleTemplate = e.newValue;
+                this.updateTitle();
+            } else if (e.preferenceName === 'window.titleSeparator') {
+                this.separator = e.newValue;
+                this.updateTitle();
+            }
+        });
+    }
+
+    get onDidChangeTitle(): Event<string> {
+        return this.onDidChangeTitleEmitter.event;
+    }
+
+    get title(): string {
+        return this._title;
+    }
+
+    update(parts: Record<string, string | undefined>): void {
+        for (const [key, value] of Object.entries(parts)) {
+            this.titleParts.set(key, value);
+        }
+        this.updateTitle();
+    }
+
+    protected updateTitle(): void {
+        if (!this.titleTemplate) {
+            this._title = '';
+        } else {
+            let title = this.titleTemplate;
+            for (const [key, value] of this.titleParts.entries()) {
+                if (key !== 'developmentHost') {
+                    const label = `$\{${key}\}`;
+                    const regex = new RegExp(escapeRegExpCharacters(label), 'g');
+                    title = title.replace(regex, value ?? '');
+                }
+            }
+            const separatedTitle = title.split('${separator}').filter(e => e.trim().length > 0);
+            this._title = separatedTitle.join(this.separator);
+        }
+        const developmentHost = this.titleParts.get('developmentHost');
+        if (developmentHost) {
+            this._title = developmentHost + this.separator + this._title;
+        }
+        document.title = this._title;
+        this.onDidChangeTitleEmitter.fire(this._title);
+    }
+
+}

package/src/browser/window/window-title-updater.ts

@@ -0,0 +1,94 @@
+// *****************************************************************************
+// Copyright (C) 2022 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Widget } from '../widgets';
+import { FrontendApplication, FrontendApplicationContribution } from '../frontend-application';
+import { NavigatableWidget } from '../navigatable-types';
+import { inject, injectable } from 'inversify';
+import { WindowTitleService } from './window-title-service';
+import { LabelProvider } from '../label-provider';
+import { Saveable } from '../saveable';
+import { Disposable } from '../../common';
+
+@injectable()
+export class WindowTitleUpdater implements FrontendApplicationContribution {
+
+    @inject(WindowTitleService)
+    protected readonly windowTitleService: WindowTitleService;
+
+    @inject(LabelProvider)
+    protected readonly labelProvider: LabelProvider;
+
+    onStart(app: FrontendApplication): void {
+        app.shell.mainPanel.onDidChangeCurrent(title => this.handleWidgetChange(title?.owner));
+        this.handleWidgetChange(app.shell.getCurrentWidget('main'));
+    }
+
+    protected toDisposeOnWidgetChanged: Disposable = Disposable.NULL;
+    protected handleWidgetChange(widget?: Widget): void {
+        this.toDisposeOnWidgetChanged.dispose();
+        const saveable = Saveable.get(widget);
+        if (saveable) {
+            this.toDisposeOnWidgetChanged = saveable.onDirtyChanged(() => this.windowTitleService.update({ dirty: saveable.dirty ? '●' : '' }));
+        } else {
+            this.toDisposeOnWidgetChanged = Disposable.NULL;
+        }
+        this.updateTitleWidget(widget);
+    }
+
+    /**
+     * Updates the title of the application based on the currently opened widget.
+     *
+     * @param widget The current widget in the `main` application area. `undefined` if no widget is currently open in that area.
+     */
+    protected updateTitleWidget(widget?: Widget): void {
+        let activeEditorLong: string | undefined;
+        let activeEditorMedium: string | undefined;
+        let activeEditorShort: string | undefined;
+        let activeFolderLong: string | undefined;
+        let activeFolderMedium: string | undefined;
+        let activeFolderShort: string | undefined;
+        let dirty: string | undefined;
+        const uri = NavigatableWidget.getUri(widget);
+        if (uri) {
+            activeEditorLong = uri.path.fsPath();
+            activeEditorMedium = this.labelProvider.getLongName(uri);
+            activeEditorShort = this.labelProvider.getName(uri);
+            const parent = uri.parent;
+            activeFolderLong = parent.path.fsPath();
+            activeFolderMedium = this.labelProvider.getLongName(parent);
+            activeFolderShort = this.labelProvider.getName(parent);
+        } else if (widget) {
+            const widgetTitle = widget.title.label;
+            activeEditorLong = widgetTitle;
+            activeEditorMedium = widgetTitle;
+            activeEditorShort = widgetTitle;
+        }
+        if (Saveable.isDirty(widget)) {
+            dirty = '●';
+        }
+        this.windowTitleService.update({
+            activeEditorLong,
+            activeEditorMedium,
+            activeEditorShort,
+            activeFolderLong,
+            activeFolderMedium,
+            activeFolderShort,
+            dirty
+        });
+    }
+
+}

package/src/common/event.ts

@@ -307,7 +307,13 @@ export class Emitter<T = any> {
     }
 }
 
+export type WaitUntilData<T> = Omit<T, 'waitUntil' | 'token'>;
+
 export interface WaitUntilEvent {
+    /**
+     * A cancellation token.
+     */
+    token: CancellationToken;
     /**
      * Allows to pause the event loop until the provided thenable resolved.
      *
@@ -325,11 +331,13 @@ export namespace WaitUntilEvent {
      */
     export async function fire<T extends WaitUntilEvent>(
         emitter: Emitter<T>,
-        event: Omit<T, 'waitUntil'>,
-        timeout: number | undefined = undefined
+        event: WaitUntilData<T>,
+        timeout?: number,
+        token = CancellationToken.None
     ): Promise<void> {
         const waitables: Promise<void>[] = [];
         const asyncEvent = Object.assign(event, {
+            token,
             waitUntil: (thenable: Promise<any>) => {
                 if (Object.isFrozen(waitables)) {
                     throw new Error('waitUntil cannot be called asynchronously.');
@@ -364,7 +372,7 @@ export class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
     /**
      * Fire listeners async one after another.
      */
-    override fire(event: Omit<T, 'waitUntil'>, token: CancellationToken = CancellationToken.None,
+    override fire(event: WaitUntilData<T>, token: CancellationToken = CancellationToken.None,
         promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void> {
         const callbacks = this._callbacks;
         if (!callbacks) {
@@ -377,7 +385,7 @@ export class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
         return this.deliveryQueue = this.deliver(listeners, event, token, promiseJoin);
     }
 
-    protected async deliver(listeners: Callback[], event: Omit<T, 'waitUntil'>, token: CancellationToken,
+    protected async deliver(listeners: Callback[], event: WaitUntilData<T>, token: CancellationToken,
         promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void> {
         for (const listener of listeners) {
             if (token.isCancellationRequested) {
@@ -385,6 +393,7 @@ export class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
             }
             const waitables: Promise<void>[] = [];
             const asyncEvent = Object.assign(event, {
+                token,
                 waitUntil: (thenable: Promise<any>) => {
                     if (Object.isFrozen(waitables)) {
                         throw new Error('waitUntil cannot be called asynchronously.');

package/src/common/json-schema.ts

@@ -85,6 +85,7 @@ export interface IJSONSchema {
     errorMessage?: string; // VSCode extension
     patternErrorMessage?: string; // VSCode extension
     deprecationMessage?: string; // VSCode extension
+    enumItemLabels?: string[]; // VSCode extension
     enumDescriptions?: string[]; // VSCode extension
     markdownEnumDescriptions?: string[]; // VSCode extension
     markdownDescription?: string; // VSCode extension

package/src/common/message-rpc/rpc-message-encoder.ts

@@ -120,7 +120,7 @@ export interface RpcMessageEncoder {
 
 }
 
-export const defaultMsgPack = new MsgPack({ moreTypes: true, encodeUndefinedAsNil: false, bundleStrings: true });
+export const defaultMsgPack = new MsgPack({ moreTypes: true, encodeUndefinedAsNil: false, bundleStrings: false });
 // Add custom msgpackR extension for ResponseErrors.
 addExtension({
     Class: ResponseError,

package/src/common/message-rpc/rpc-protocol.ts

@@ -132,23 +132,23 @@ export class RpcProtocol {
         // The last element of the request args might be a cancellation token. As these tokens are not serializable we have to remove it from the
         // args array and the `CANCELLATION_TOKEN_KEY` string instead.
         const cancellationToken: CancellationToken | undefined = args.length && CancellationToken.is(args[args.length - 1]) ? args.pop() : undefined;
-        if (cancellationToken && cancellationToken.isCancellationRequested) {
-            return Promise.reject(this.cancelError());
-        }
 
         if (cancellationToken) {
             args.push(RpcProtocol.CANCELLATION_TOKEN_KEY);
-            cancellationToken.onCancellationRequested(() => {
-                this.sendCancel(id);
-                this.pendingRequests.get(id)?.reject(this.cancelError());
-            }
-            );
         }
+
         this.pendingRequests.set(id, reply);
 
         const output = this.channel.getWriteBuffer();
         this.encoder.request(output, id, method, args);
         output.commit();
+
+        if (cancellationToken?.isCancellationRequested) {
+            this.sendCancel(id);
+        } else {
+            cancellationToken?.onCancellationRequested(() => this.sendCancel(id));
+        }
+
         return reply.promise;
     }
 
@@ -164,12 +164,6 @@ export class RpcProtocol {
         output.commit();
     }
 
-    cancelError(): Error {
-        const error = new Error('"Request has already been canceled by the sender"');
-        error.name = 'Cancel';
-        return error;
-    }
-
     protected handleCancel(id: number): void {
         const cancellationTokenSource = this.cancellationTokenSources.get(id);
         if (cancellationTokenSource) {