@theia/core 1.27.0-next.9 → 1.27.0

package/src/browser/connection-status-service.spec.ts

@@ -19,10 +19,7 @@ import { enableJSDOM } from '../browser/test/jsdom';
 let disableJSDOM = enableJSDOM();
 
 import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
-import { ApplicationProps } from '@theia/application-package/lib/application-props';
-FrontendApplicationConfigProvider.set({
-    ...ApplicationProps.DEFAULT.frontend.config
-});
+FrontendApplicationConfigProvider.set({});
 
 import { expect } from 'chai';
 import {

package/src/browser/connection-status-service.ts

@@ -20,7 +20,7 @@ import { Event, Emitter } from '../common/event';
 import { DefaultFrontendApplicationContribution } from './frontend-application';
 import { StatusBar, StatusBarAlignment } from './status-bar/status-bar';
 import { WebSocketConnectionProvider } from './messaging/ws-connection-provider';
-import { Disposable, DisposableCollection } from '../common';
+import { Disposable, DisposableCollection, nls } from '../common';
 
 /**
  * Service for listening on backend connection changes.
@@ -205,8 +205,8 @@ export class ApplicationConnectionStatusContribution extends DefaultFrontendAppl
     protected handleOffline(): void {
         this.statusBar.setElement(this.statusbarId, {
             alignment: StatusBarAlignment.LEFT,
-            text: 'Offline',
-            tooltip: 'Cannot connect to backend.',
+            text: nls.localize('theia/core/offline', 'Offline'),
+            tooltip: nls.localize('theia/localize/offlineTooltip', 'Cannot connect to backend.'),
             priority: 5000
         });
         this.toDisposeOnOnline.push(Disposable.create(() => this.statusBar.removeElement(this.statusbarId)));

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

@@ -79,11 +79,8 @@ export abstract class ContextMenuRenderer {
         }
     }
 
-    render(options: RenderContextMenuOptions): ContextMenuAccess;
-    /** @deprecated since 0.7.2 pass `RenderContextMenuOptions` instead */
-    render(menuPath: MenuPath, anchor: Anchor, onHide?: () => void): ContextMenuAccess;
-    render(menuPathOrOptions: MenuPath | RenderContextMenuOptions, anchor?: Anchor, onHide?: () => void): ContextMenuAccess {
-        const resolvedOptions = RenderContextMenuOptions.resolve(menuPathOrOptions, anchor, onHide);
+    render(options: RenderContextMenuOptions): ContextMenuAccess {
+        const resolvedOptions = this.resolve(options);
         const access = this.doRender(resolvedOptions);
         this.setCurrent(access);
         return access;
@@ -91,6 +88,17 @@ export abstract class ContextMenuRenderer {
 
     protected abstract doRender(options: RenderContextMenuOptions): ContextMenuAccess;
 
+    protected resolve(options: RenderContextMenuOptions): RenderContextMenuOptions {
+        const args: any[] = options.args ? options.args.slice() : [];
+        if (options.includeAnchorArg !== false) {
+            args.push(options.anchor);
+        }
+        return {
+            ...options,
+            args
+        };
+    }
+
 }
 
 export interface RenderContextMenuOptions {
@@ -106,27 +114,3 @@ export interface RenderContextMenuOptions {
     includeAnchorArg?: boolean;
     onHide?: () => void;
 }
-export namespace RenderContextMenuOptions {
-    export function resolve(menuPathOrOptions: MenuPath | RenderContextMenuOptions, anchor?: Anchor, onHide?: () => void): RenderContextMenuOptions {
-        let menuPath: MenuPath;
-        let args: any[];
-        if (Array.isArray(menuPathOrOptions)) {
-            menuPath = menuPathOrOptions;
-            args = [anchor!];
-        } else {
-            menuPath = menuPathOrOptions.menuPath;
-            anchor = menuPathOrOptions.anchor;
-            onHide = menuPathOrOptions.onHide;
-            args = menuPathOrOptions.args ? menuPathOrOptions.args.slice() : [];
-            if (menuPathOrOptions.includeAnchorArg !== false) {
-                args.push(anchor);
-            }
-        }
-        return {
-            menuPath,
-            anchor: anchor!,
-            onHide,
-            args
-        };
-    }
-}

package/src/browser/core-preferences.ts

@@ -198,6 +198,11 @@ export const corePreferenceSchema: PreferenceSchema = {
                 'Controls the feedback area size in pixels of the dragging area in between views/editors. Set it to a larger value if needed.'
             )
         },
+        'workbench.tab.maximize': {
+            type: 'boolean',
+            default: false,
+            description: nls.localize('theia/core/tabMaximize', 'Controls whether to maximize tabs on double click.')
+        }
     }
 };
 
@@ -220,6 +225,7 @@ export interface CoreConfiguration {
     'workbench.hover.delay': number;
     'workbench.sash.hoverDelay': number;
     'workbench.sash.size': number;
+    'workbench.tab.maximize': boolean;
 }
 
 export const CorePreferenceContribution = Symbol('CorePreferenceContribution');

package/src/browser/decoration-style.ts

@@ -16,14 +16,18 @@
 
 export namespace DecorationStyle {
 
-    export function createStyleSheet(styleId: string, container: HTMLElement = document.getElementsByTagName('head')[0]): CSSStyleSheet {
+    export function createStyleElement(styleId: string, container: HTMLElement = document.head): HTMLStyleElement {
         const style = document.createElement('style');
         style.id = styleId;
         style.type = 'text/css';
         style.media = 'screen';
         style.appendChild(document.createTextNode('')); // trick for webkit
         container.appendChild(style);
-        return <CSSStyleSheet>style.sheet;
+        return style;
+    }
+
+    export function createStyleSheet(styleId: string, container?: HTMLElement): CSSStyleSheet {
+        return <CSSStyleSheet>createStyleElement(styleId, container).sheet;
     }
 
     function getRuleIndex(selector: string, styleSheet: CSSStyleSheet): number {

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

@@ -25,7 +25,6 @@ import {
     PreferenceService, PreferenceServiceImpl, PreferenceValidationService
 } from './preferences';
 import { InjectablePreferenceProxy, PreferenceProxyFactory, PreferenceProxySchema } from './preferences/injectable-preference-proxy';
-import { ValidatedPreferenceProxy } from './preferences/validated-preference-proxy';
 
 export function bindMessageService(bind: interfaces.Bind): interfaces.BindingWhenOnSyntax<MessageService> {
     bind(MessageClient).toSelf().inSingletonScope();
@@ -47,12 +46,11 @@ export function bindPreferenceService(bind: interfaces.Bind): void {
     bindPreferenceSchemaProvider(bind);
     bind(PreferenceValidationService).toSelf().inSingletonScope();
     bind(InjectablePreferenceProxy).toSelf();
-    bind(ValidatedPreferenceProxy).toSelf();
     bind(PreferenceProxyFactory).toFactory(({ container }) => (schema: MaybePromise<PreferenceSchema>, options: PreferenceProxyOptions = {}) => {
         const child = container.createChild();
         child.bind(PreferenceProxyOptions).toConstantValue(options ?? {});
         child.bind(PreferenceProxySchema).toConstantValue(schema);
-        const handler = options.validated ? child.get(ValidatedPreferenceProxy) : child.get(InjectablePreferenceProxy);
+        const handler = child.get(InjectablePreferenceProxy);
         return new Proxy(Object.create(null), handler); // eslint-disable-line no-null/no-null
     });
 }

package/src/browser/frontend-application-config-provider.ts

@@ -16,6 +16,8 @@
 
 import { FrontendApplicationConfig, deepmerge } from '@theia/application-package/lib/application-props';
 
+export const DEFAULT_BACKGROUND_COLOR_STORAGE_KEY = 'theme.background';
+
 export class FrontendApplicationConfigProvider {
 
     private static KEY = Symbol('FrontendApplicationConfigProvider');

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

@@ -126,11 +126,11 @@ import { UserWorkingDirectoryProvider } from './user-working-directory-provider'
 import { TheiaDockPanel } from './shell/theia-dock-panel';
 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';
 
 export { bindResourceProvider, bindMessageService, bindPreferenceService };
 
-ColorApplicationContribution.initBackground();
-
 export const frontendApplicationModule = new ContainerModule((bind, _unbind, _isBound, _rebind) => {
     bind(NoneIconTheme).toSelf().inSingletonScope();
     bind(LabelProviderContribution).toService(NoneIconTheme);
@@ -178,7 +178,8 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
         const iconThemeService = container.get(IconThemeService);
         const selectionService = container.get(SelectionService);
         const commandService = container.get<CommandService>(CommandService);
-        return new TabBarRenderer(contextMenuRenderer, tabBarDecoratorService, iconThemeService, selectionService, commandService);
+        const corePreferences = container.get<CorePreferences>(CorePreferences);
+        return new TabBarRenderer(contextMenuRenderer, tabBarDecoratorService, iconThemeService, selectionService, commandService, corePreferences);
     });
     bind(TheiaDockPanel.Factory).toFactory(({ container }) => options => {
         const corePreferences = container.get<CorePreferences>(CorePreferences);
@@ -263,6 +264,8 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
         bind(serviceIdentifier).toService(CommonFrontendContribution)
     );
 
+    bindCommonStylingParticipants(bind);
+
     bind(QuickCommandFrontendContribution).toSelf().inSingletonScope();
     [CommandContribution, KeybindingContribution, MenuContribution].forEach(serviceIdentifier =>
         bind(serviceIdentifier).toService(QuickCommandFrontendContribution)
@@ -338,7 +341,7 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
         return connection.createProxy<EnvVariablesServer>(envVariablesPath);
     }).inSingletonScope();
 
-    bind(ThemeService).toDynamicValue(() => ThemeService.get());
+    bind(ThemeService).toSelf().inSingletonScope();
 
     bindCorePreferences(bind);
 
@@ -417,4 +420,8 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
 
     bind(SaveResourceService).toSelf().inSingletonScope();
     bind(UserWorkingDirectoryProvider).toSelf().inSingletonScope();
+
+    bind(StylingService).toSelf().inSingletonScope();
+    bindContributionProvider(bind, StylingParticipant);
+    bind(FrontendApplicationContribution).toService(StylingService);
 });

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

@@ -17,9 +17,11 @@
 import { ContainerModule } from 'inversify';
 import { AsyncLocalizationProvider, localizationPath } from '../../common/i18n/localization';
 import { WebSocketConnectionProvider } from '../messaging/ws-connection-provider';
+import { LanguageQuickPickService } from './language-quick-pick-service';
 
 export default new ContainerModule(bind => {
     bind(AsyncLocalizationProvider).toDynamicValue(
         ctx => ctx.container.get(WebSocketConnectionProvider).createProxy(localizationPath)
     ).inSingletonScope();
+    bind(LanguageQuickPickService).toSelf().inSingletonScope();
 });

package/src/browser/i18n/language-quick-pick-service.ts

@@ -0,0 +1,128 @@
+// *****************************************************************************
+// 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 } from 'inversify';
+import { nls } from '../../common/nls';
+import { AsyncLocalizationProvider, LanguageInfo } from '../../common/i18n/localization';
+import { QuickInputService, QuickPickItem, QuickPickSeparator } from '../quick-input';
+import { WindowService } from '../window/window-service';
+
+export interface LanguageQuickPickItem extends QuickPickItem {
+    languageId: string
+    execute?(): Promise<void>
+}
+
+@injectable()
+export class LanguageQuickPickService {
+
+    @inject(QuickInputService) protected readonly quickInputService: QuickInputService;
+    @inject(AsyncLocalizationProvider) protected readonly localizationProvider: AsyncLocalizationProvider;
+    @inject(WindowService) protected readonly windowService: WindowService;
+
+    async pickDisplayLanguage(): Promise<string | undefined> {
+        const quickInput = this.quickInputService.createQuickPick<LanguageQuickPickItem>();
+        const installedItems = await this.getInstalledLanguages();
+        const quickInputItems: (LanguageQuickPickItem | QuickPickSeparator)[] = [
+            {
+                type: 'separator',
+                label: nls.localize('theia/core/installedLanguages', 'Installed languages')
+            },
+            ...installedItems
+        ];
+        quickInput.items = quickInputItems;
+        quickInput.busy = true;
+        const selected = installedItems.find(item => nls.isSelectedLocale(item.languageId));
+        if (selected) {
+            quickInput.activeItems = [selected];
+        }
+        quickInput.placeholder = nls.localizeByDefault('Configure Display Language');
+        quickInput.show();
+
+        this.getAvailableLanguages().then(availableItems => {
+            if (availableItems.length > 0) {
+                quickInputItems.push({
+                    type: 'separator',
+                    label: nls.localize('theia/core/availableLanguages', 'Available languages')
+                });
+                const installed = new Set(installedItems.map(e => e.languageId));
+                for (const available of availableItems) {
+                    // Exclude already installed languages
+                    if (!installed.has(available.languageId)) {
+                        quickInputItems.push(available);
+                    }
+                }
+                quickInput.items = quickInputItems;
+            }
+        }).finally(() => {
+            quickInput.busy = false;
+        });
+
+        return new Promise(resolve => {
+            quickInput.onDidAccept(async () => {
+                const selectedItem = quickInput.selectedItems[0];
+                if (selectedItem) {
+                    // Some language quick pick items want to install additional languages
+                    // We have to await that before returning the selected locale
+                    await selectedItem.execute?.();
+                    resolve(selectedItem.languageId);
+                } else {
+                    resolve(undefined);
+                }
+            });
+            quickInput.onDidHide(() => {
+                resolve(undefined);
+            });
+        });
+    }
+
+    protected async getInstalledLanguages(): Promise<LanguageQuickPickItem[]> {
+        const languageInfos = await this.localizationProvider.getAvailableLanguages();
+        const items: LanguageQuickPickItem[] = [];
+        const en: LanguageInfo = {
+            languageId: 'en',
+            languageName: 'English',
+            localizedLanguageName: 'English'
+        };
+        languageInfos.push(en);
+        for (const language of languageInfos.filter(e => !!e.languageId)) {
+            items.push(this.createLanguageQuickPickItem(language));
+        }
+        return items;
+    }
+
+    protected async getAvailableLanguages(): Promise<LanguageQuickPickItem[]> {
+        return [];
+    }
+
+    protected createLanguageQuickPickItem(language: LanguageInfo): LanguageQuickPickItem {
+        let label: string;
+        let description: string | undefined;
+        const languageName = language.localizedLanguageName || language.languageName;
+        const id = language.languageId;
+        const idLabel = id + (nls.isSelectedLocale(id) ? ` (${nls.localizeByDefault('Current')})` : '');
+        if (languageName) {
+            label = languageName;
+            description = idLabel;
+        } else {
+            label = idLabel;
+        }
+        return {
+            label,
+            description,
+            languageId: id
+        };
+    }
+}

package/src/browser/index.ts

@@ -42,3 +42,4 @@ export * from './view-container';
 export * from './breadcrumbs';
 export * from './tooltip-service';
 export * from './decoration-style';
+export * from './styling-service';

package/src/browser/keybinding.spec.ts

@@ -14,9 +14,12 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { enableJSDOM } from '../browser/test/jsdom';
+import { enableJSDOM } from './test/jsdom';
 let disableJSDOM = enableJSDOM();
 
+import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
 import { Container, injectable, ContainerModule } from 'inversify';
 import { bindContributionProvider } from '../common/contribution-provider';
 import { KeyboardLayoutProvider, NativeKeyboardLayout, KeyboardLayoutChangeNotifier } from '../common/keyboard/keyboard-layout-provider';
@@ -36,10 +39,8 @@ import * as chai from 'chai';
 import * as sinon from 'sinon';
 import { Emitter, Event } from '../common/event';
 import { bindPreferenceService } from './frontend-application-bindings';
-import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
-import { ApplicationProps } from '@theia/application-package/lib/';
-import { bindStatusBar } from './status-bar';
 import { MarkdownRenderer, MarkdownRendererFactory, MarkdownRendererImpl } from './markdown-rendering/markdown-renderer';
+import { StatusBar } from './status-bar';
 
 disableJSDOM();
 
@@ -51,7 +52,11 @@ let keybindingRegistry: KeybindingRegistry;
 let commandRegistry: CommandRegistry;
 let testContainer: Container;
 
+let stub: sinon.SinonStub;
+
 before(async () => {
+    disableJSDOM = enableJSDOM();
+
     testContainer = new Container();
     const module = new ContainerModule((bind, unbind, isBound, rebind) => {
 
@@ -84,7 +89,7 @@ before(async () => {
             }
         });
 
-        bindStatusBar(bind);
+        bind(StatusBar).toConstantValue({} as StatusBar);
         bind(MarkdownRendererImpl).toSelf().inSingletonScope();
         bind(MarkdownRenderer).toService(MarkdownRendererImpl);
         bind(MarkdownRendererFactory).toFactory(({ container }) => container.get(MarkdownRenderer));
@@ -103,31 +108,21 @@ before(async () => {
 
 });
 
-describe('keybindings', () => {
-
-    let stub: sinon.SinonStub;
-
-    before(() => {
-        disableJSDOM = enableJSDOM();
-        FrontendApplicationConfigProvider.set({
-            ...ApplicationProps.DEFAULT.frontend.config,
-            'applicationName': 'test'
-        });
-    });
+after(() => {
+    disableJSDOM();
+});
 
-    after(() => {
-        disableJSDOM();
-    });
+beforeEach(async () => {
+    stub = sinon.stub(os, 'isOSX').value(false);
+    keybindingRegistry = testContainer.get<KeybindingRegistry>(KeybindingRegistry);
+    await keybindingRegistry.onStart();
+});
 
-    beforeEach(async () => {
-        stub = sinon.stub(os, 'isOSX').value(false);
-        keybindingRegistry = testContainer.get<KeybindingRegistry>(KeybindingRegistry);
-        await keybindingRegistry.onStart();
-    });
+afterEach(() => {
+    stub.restore();
+});
 
-    afterEach(() => {
-        stub.restore();
-    });
+describe('keybindings', () => {
 
     it('should register the default keybindings', () => {
         const keybinding = keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id);

package/src/browser/keybinding.ts

@@ -27,6 +27,7 @@ import { StatusBarAlignment, StatusBar } from './status-bar/status-bar';
 import { ContextKeyService } from './context-key-service';
 import { CorePreferences } from './core-preferences';
 import * as common from '../common/keybinding';
+import { nls } from '../common/nls';
 
 export enum KeybindingScope {
     DEFAULT,
@@ -559,7 +560,7 @@ export class KeybindingRegistry {
             event.stopPropagation();
 
             this.statusBar.setElement('keybinding-status', {
-                text: `(${this.acceleratorForSequence(this.keySequence, '+')}) was pressed, waiting for more keys`,
+                text: nls.localize('theia/core/keybindingStatus', '{0} was pressed, waiting for more keys', `(${this.acceleratorForSequence(this.keySequence, '+')})`),
                 alignment: StatusBarAlignment.LEFT,
                 priority: 2
             });

package/src/browser/label-provider.ts

@@ -34,19 +34,6 @@ const DEFAULT_FOLDER_ICON = `${codicon('folder')} default-folder-icon`;
  */
 const DEFAULT_FILE_ICON = `${codicon('file')} default-file-icon`;
 
-/**
- * Internal folder icon class for the default (File Icons) theme.
- *
- * @deprecated Use `LabelProvider.folderIcon` to get a folder icon class for the current icon theme.
- */
-export const FOLDER_ICON = DEFAULT_FOLDER_ICON;
-/**
- * Internal file icon class for the default (File Icons) theme.
- *
- * @deprecated Use `LabelProvider.fileIcon` to get a file icon class for the current icon theme.
- */
-export const FILE_ICON = DEFAULT_FILE_ICON;
-
 export const LabelProviderContribution = Symbol('LabelProviderContribution');
 /**
  * A {@link LabelProviderContribution} determines how specific elements/nodes are displayed in the workbench.

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

@@ -20,6 +20,7 @@ import { ILogger, Logger, LoggerFactory, setRootLogger, LoggerName, rootLoggerNa
 import { LoggerWatcher } from '../common/logger-watcher';
 import { WebSocketConnectionProvider } from './messaging';
 import { FrontendApplicationContribution } from './frontend-application';
+import { EncodingError } from '../common/message-rpc/rpc-message-encoder';
 
 export const loggerFrontendModule = new ContainerModule(bind => {
     bind(FrontendApplicationContribution).toDynamicValue(ctx => ({
@@ -39,7 +40,13 @@ export const loggerFrontendModule = new ContainerModule(bind => {
             if (property === 'log') {
                 return (name, logLevel, message, params) => {
                     ConsoleLogger.log(name, logLevel, message, params);
-                    return target.log(name, logLevel, message, params);
+                    return target.log(name, logLevel, message, params).catch(err => {
+                        if (err instanceof EncodingError) {
+                            // In case of an EncodingError no RPC call is sent to the backend `ILoggerServer`. Nevertheless, we want to continue normally.
+                            return;
+                        }
+                        throw err;
+                    });
                 };
             }
             return target[property];

package/src/browser/messaging/ws-connection-provider.ts

@@ -15,11 +15,11 @@
 // *****************************************************************************
 
 import { injectable, interfaces, decorate, unmanaged } from 'inversify';
-import { JsonRpcProxyFactory, JsonRpcProxy, Emitter, Event } from '../../common';
-import { WebSocketChannel } from '../../common/messaging/web-socket-channel';
+import { JsonRpcProxyFactory, JsonRpcProxy, Emitter, Event, Channel } from '../../common';
 import { Endpoint } from '../endpoint';
 import { AbstractConnectionProvider } from '../../common/messaging/abstract-connection-provider';
 import { io, Socket } from 'socket.io-client';
+import { IWebSocket, WebSocketChannel } from '../../common/messaging/web-socket-channel';
 
 decorate(injectable(), JsonRpcProxyFactory);
 decorate(unmanaged(), JsonRpcProxyFactory, 0);
@@ -53,26 +53,42 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
     constructor() {
         super();
         const url = this.createWebSocketUrl(WebSocketChannel.wsPath);
-        const socket = this.createWebSocket(url);
-        socket.on('connect', () => {
-            this.fireSocketDidOpen();
-        });
-        socket.on('disconnect', reason => {
-            for (const channel of [...this.channels.values()]) {
-                channel.close(undefined, reason);
+        this.socket = this.createWebSocket(url);
+        this.socket.on('connect', () => {
+            this.initializeMultiplexer();
+            if (this.reconnectChannelOpeners.length > 0) {
+                this.reconnectChannelOpeners.forEach(opener => opener());
+                this.reconnectChannelOpeners = [];
             }
-            this.fireSocketDidClose();
-        });
-        socket.on('message', data => {
-            this.handleIncomingRawMessage(data);
+            this.socket.on('disconnect', () => this.fireSocketDidClose());
+            this.socket.on('message', () => this.onIncomingMessageActivityEmitter.fire(undefined));
+            this.fireSocketDidOpen();
         });
-        socket.connect();
-        this.socket = socket;
+        this.socket.connect();
     }
 
-    override openChannel(path: string, handler: (channel: WebSocketChannel) => void, options?: WebSocketOptions): void {
+    protected createMainChannel(): Channel {
+        return new WebSocketChannel(this.toIWebSocket(this.socket));
+    }
+
+    protected toIWebSocket(socket: Socket): IWebSocket {
+        return {
+            close: () => {
+                socket.removeAllListeners('disconnect');
+                socket.removeAllListeners('error');
+                socket.removeAllListeners('message');
+            },
+            isConnected: () => socket.connected,
+            onClose: cb => socket.on('disconnect', reason => cb(reason)),
+            onError: cb => socket.on('error', reason => cb(reason)),
+            onMessage: cb => socket.on('message', data => cb(data)),
+            send: message => socket.emit('message', message)
+        };
+    }
+
+    override async openChannel(path: string, handler: (channel: Channel) => void, options?: WebSocketOptions): Promise<void> {
         if (this.socket.connected) {
-            super.openChannel(path, handler, options);
+            return super.openChannel(path, handler, options);
         } else {
             const openChannel = () => {
                 this.socket.off('connect', openChannel);
@@ -82,14 +98,6 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
         }
     }
 
-    protected createChannel(id: number): WebSocketChannel {
-        return new WebSocketChannel(id, content => {
-            if (this.socket.connected) {
-                this.socket.send(content);
-            }
-        });
-    }
-
     /**
      * @param path The handler to reach in the backend.
      */
@@ -143,3 +151,4 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
         this.onSocketDidCloseEmitter.fire(undefined);
     }
 }
+

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

@@ -20,21 +20,16 @@ import { ContributionProvider, bindContributionProvider, Emitter, Event, Disposa
 import { PreferenceScope } from './preference-scope';
 import { PreferenceProvider, PreferenceProviderDataChange } from './preference-provider';
 import {
-    PreferenceSchema, PreferenceSchemaProperties, PreferenceDataSchema, PreferenceItem, PreferenceSchemaProperty, PreferenceDataProperty, JsonType
+    PreferenceSchema, PreferenceSchemaProperties, PreferenceDataSchema, PreferenceItem, PreferenceSchemaProperty, PreferenceDataProperty
 } from '../../common/preferences/preference-schema';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
 import { FrontendApplicationConfig } from '@theia/application-package/lib/application-props';
 import { bindPreferenceConfigurations, PreferenceConfigurations } from './preference-configurations';
-export { PreferenceSchema, PreferenceSchemaProperties, PreferenceDataSchema, PreferenceItem, PreferenceSchemaProperty, PreferenceDataProperty, JsonType };
+export { PreferenceSchema, PreferenceSchemaProperties, PreferenceDataSchema, PreferenceItem, PreferenceSchemaProperty, PreferenceDataProperty };
 import { Mutable } from '../../common/types';
-import { OverridePreferenceName, PreferenceLanguageOverrideService } from './preference-language-override-service';
+import { PreferenceLanguageOverrideService } from './preference-language-override-service';
 import { JSONValue } from '@phosphor/coreutils';
 
-/**
- * @deprecated since 1.13.0 import from @theia/core/lib/browser/preferences/preference-language-override-service.
- */
-export { OVERRIDE_PROPERTY_PATTERN } from './preference-language-override-service';
-
 /* eslint-disable guard-for-in, @typescript-eslint/no-explicit-any */
 
 export const PreferenceContribution = Symbol('PreferenceContribution');
@@ -400,24 +395,4 @@ export class PreferenceSchemaProvider extends PreferenceProvider {
         }
     }
 
-    /**
-     * @deprecated since 1.13.0 use `PreferenceLanguageOverrideService.overridePreferenceName`
-     */
-    overridePreferenceName(override: OverridePreferenceName): string {
-        return this.preferenceOverrideService.overridePreferenceName(override);
-    }
-
-    /**
-     * @deprecated since 1.13.0 use `PreferenceLanguageOverrideService.testOverrideValue`
-     */
-    testOverrideValue(name: string, value: any): value is PreferenceSchemaProperties {
-        return this.preferenceOverrideService.testOverrideValue(name, value);
-    }
-
-    /**
-     * @deprecated since 1.13.0 use `PreferenceLanguageOverrideService.overriddenPreferenceName`
-     */
-    overriddenPreferenceName(name: string): OverridePreferenceName | undefined {
-        return this.preferenceOverrideService.overriddenPreferenceName(name);
-    }
 }