@theia/core 1.43.1 → 1.45.0

package/src/browser/language-service.ts

@@ -15,16 +15,19 @@
 // *****************************************************************************
 
 import { injectable } from 'inversify';
+import { Disposable, Emitter, Event } from '../common';
 
 export interface Language {
     readonly id: string;
     readonly name: string;
     readonly extensions: Set<string>;
     readonly filenames: Set<string>;
+    readonly iconClass?: string;
 }
 
 @injectable()
 export class LanguageService {
+    protected readonly onDidChangeIconEmitter = new Emitter<DidChangeIconEvent>();
 
     /**
      * It should be implemented by an extension, e.g. by the monaco extension.
@@ -40,4 +43,35 @@ export class LanguageService {
         return undefined;
     }
 
+    /**
+     * It should be implemented by an extension, e.g. by the monaco extension.
+     */
+    detectLanguage(obj: unknown): Language | undefined {
+        return undefined;
+    }
+
+    /**
+     * It should be implemented by an extension, e.g. by the monaco extension.
+     */
+    registerIcon(languageId: string, iconClass: string): Disposable {
+        return Disposable.NULL;
+    }
+
+    /**
+     * It should be implemented by an extension, e.g. by the monaco extension.
+     */
+    getIcon(obj: unknown): string | undefined {
+        return undefined;
+    }
+
+    /**
+     * Emit when the icon of a particular language was changed.
+     */
+    get onDidChangeIcon(): Event<DidChangeIconEvent> {
+        return this.onDidChangeIconEmitter.event;
+    }
+}
+
+export interface DidChangeIconEvent {
+    languageId: string;
 }

package/src/browser/messaging/connection-source.ts

@@ -0,0 +1,26 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Channel, Event } from '../../common';
+
+export const ConnectionSource = Symbol('ConnectionSource');
+
+/**
+ * A ConnectionSource creates a Channel. The channel is valid until it sends a close event.
+ */
+export interface ConnectionSource {
+    onConnectionDidOpen: Event<Channel>;
+}

package/src/browser/messaging/frontend-id-provider.ts

@@ -0,0 +1,37 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from 'inversify';
+import { generateUuid } from '../../common/uuid';
+
+export const FrontendIdProvider = Symbol('FrontendIdProvider');
+
+/**
+ * A FrontendIdProvider computes an id for an instance of the front end that may be reconnected to a back end
+ * connection context.
+ */
+export interface FrontendIdProvider {
+    getId(): string;
+}
+
+@injectable()
+export class BrowserFrontendIdProvider implements FrontendIdProvider {
+    protected readonly id = generateUuid(); // generate a new id each time we load the application
+
+    getId(): string {
+        return this.id;
+    }
+}

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

@@ -15,9 +15,27 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { LocalWebSocketConnectionProvider, WebSocketConnectionProvider } from './ws-connection-provider';
+import { BrowserFrontendIdProvider, FrontendIdProvider } from './frontend-id-provider';
+import { WebSocketConnectionSource } from './ws-connection-source';
+import { LocalConnectionProvider, RemoteConnectionProvider, ServiceConnectionProvider } from './service-connection-provider';
+import { ConnectionSource } from './connection-source';
+import { ConnectionCloseService, connectionCloseServicePath } from '../../common/messaging/connection-management';
+import { WebSocketConnectionProvider } from './ws-connection-provider';
+
+const backendServiceProvider = Symbol('backendServiceProvider');
 
 export const messagingFrontendModule = new ContainerModule(bind => {
+    bind(ConnectionCloseService).toDynamicValue(ctx => WebSocketConnectionProvider.createProxy(ctx.container, connectionCloseServicePath)).inSingletonScope();
+    bind(BrowserFrontendIdProvider).toSelf().inSingletonScope();
+    bind(FrontendIdProvider).toService(BrowserFrontendIdProvider);
+    bind(WebSocketConnectionSource).toSelf().inSingletonScope();
+    bind(backendServiceProvider).toDynamicValue(ctx => {
+        bind(ServiceConnectionProvider).toSelf().inSingletonScope();
+        const container = ctx.container.createChild();
+        container.bind(ConnectionSource).toService(WebSocketConnectionSource);
+        return container.get(ServiceConnectionProvider);
+    }).inSingletonScope();
+    bind(LocalConnectionProvider).toService(backendServiceProvider);
+    bind(RemoteConnectionProvider).toService(backendServiceProvider);
     bind(WebSocketConnectionProvider).toSelf().inSingletonScope();
-    bind(LocalWebSocketConnectionProvider).toService(WebSocketConnectionProvider);
 });

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

@@ -0,0 +1,126 @@
+// *****************************************************************************
+// Copyright (C) 2020 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, interfaces, postConstruct } from 'inversify';
+import { Channel, RpcProxy, RpcProxyFactory } from '../../common';
+import { ChannelMultiplexer } from '../../common/message-rpc/channel';
+import { Deferred } from '../../common/promise-util';
+import { ConnectionSource } from './connection-source';
+
+export const LocalConnectionProvider = Symbol('LocalConnectionProvider');
+export const RemoteConnectionProvider = Symbol('RemoteConnectionProvider');
+
+export namespace ServiceConnectionProvider {
+    export type ConnectionHandler = (path: String, channel: Channel) => void;
+}
+
+/**
+ * This class manages the channels for remote services in the back end
+ */
+@injectable()
+export class ServiceConnectionProvider {
+
+    static createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
+        return container.get<ServiceConnectionProvider>(RemoteConnectionProvider).createProxy(path, arg);
+    }
+
+    static createLocalProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
+        return container.get<ServiceConnectionProvider>(LocalConnectionProvider).createProxy(path, arg);
+    }
+
+    static createHandler(container: interfaces.Container, path: string, arg?: object): void {
+        const remote = container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
+        const local = container.get<ServiceConnectionProvider>(LocalConnectionProvider);
+        remote.createProxy(path, arg);
+        if (remote !== local) {
+            local.createProxy(path, arg);
+        }
+    }
+
+    protected readonly channelHandlers = new Map<string, ServiceConnectionProvider.ConnectionHandler>();
+
+    /**
+     * Create a proxy object to remote interface of T type
+     * over a web socket connection for the given path and proxy factory.
+     */
+    createProxy<T extends object>(path: string, factory: RpcProxyFactory<T>): RpcProxy<T>;
+    /**
+     * Create a proxy object to remote interface of T type
+     * over a web socket connection for the given path.
+     *
+     * An optional target can be provided to handle
+     * notifications and requests from a remote side.
+     */
+    createProxy<T extends object>(path: string, target?: object): RpcProxy<T>;
+    createProxy<T extends object>(path: string, arg?: object): RpcProxy<T> {
+        const factory = arg instanceof RpcProxyFactory ? arg : new RpcProxyFactory<T>(arg);
+        this.listen(path, (_, c) => factory.listen(c), true);
+        return factory.createProxy();
+    }
+
+    protected channelMultiplexer: ChannelMultiplexer;
+
+    private channelReadyDeferred = new Deferred<void>();
+    protected get channelReady(): Promise<void> {
+        return this.channelReadyDeferred.promise;
+    }
+
+    @postConstruct()
+    init(): void {
+        this.connectionSource.onConnectionDidOpen(channel => this.handleChannelCreated(channel));
+    }
+
+    @inject(ConnectionSource)
+    protected connectionSource: ConnectionSource;
+
+    /**
+     * This method must be invoked by subclasses when they have created the main channel.
+     * @param mainChannel
+     */
+    protected handleChannelCreated(channel: Channel): void {
+        channel.onClose(() => {
+            this.handleChannelClosed(channel);
+        });
+
+        this.channelMultiplexer = new ChannelMultiplexer(channel);
+        this.channelReadyDeferred.resolve();
+        for (const entry of this.channelHandlers.entries()) {
+            this.openChannel(entry[0], entry[1]);
+        }
+    }
+
+    handleChannelClosed(channel: Channel): void {
+        this.channelReadyDeferred = new Deferred();
+    }
+
+    /**
+     * Install a connection handler for the given path.
+     */
+    listen(path: string, handler: ServiceConnectionProvider.ConnectionHandler, reconnect: boolean): void {
+        this.openChannel(path, handler).then(() => {
+            if (reconnect) {
+                this.channelHandlers.set(path, handler);
+            }
+        });
+
+    }
+
+    private async openChannel(path: string, handler: ServiceConnectionProvider.ConnectionHandler): Promise<void> {
+        await this.channelReady;
+        const newChannel = await this.channelMultiplexer.open(path);
+        handler(path, newChannel);
+    }
+}

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

@@ -14,160 +14,35 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, interfaces, decorate, unmanaged } from 'inversify';
-import { RpcProxyFactory, RpcProxy, 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';
+import { injectable, interfaces, decorate, unmanaged, inject } from 'inversify';
+import { RpcProxyFactory, RpcProxy } from '../../common';
+import { RemoteConnectionProvider, ServiceConnectionProvider } from './service-connection-provider';
 
 decorate(injectable(), RpcProxyFactory);
 decorate(unmanaged(), RpcProxyFactory, 0);
 
-export const LocalWebSocketConnectionProvider = Symbol('LocalWebSocketConnectionProvider');
-
-export interface WebSocketOptions {
-    /**
-     * True by default.
-     */
-    reconnecting?: boolean;
-}
-
+/**
+ * @deprecated This class serves to keep API compatibility for a while. Use {@linkcode ServiceConnectionProvider} instead.
+ */
 @injectable()
-export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebSocketOptions> {
-
-    protected readonly onSocketDidOpenEmitter: Emitter<void> = new Emitter();
-    get onSocketDidOpen(): Event<void> {
-        return this.onSocketDidOpenEmitter.event;
-    }
-
-    protected readonly onSocketDidCloseEmitter: Emitter<void> = new Emitter();
-    get onSocketDidClose(): Event<void> {
-        return this.onSocketDidCloseEmitter.event;
-    }
+export class WebSocketConnectionProvider {
+    @inject(RemoteConnectionProvider)
+    private readonly remoteConnectionProvider: ServiceConnectionProvider;
 
-    static override createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
-        return container.get(WebSocketConnectionProvider).createProxy<T>(path, arg);
+    static createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
+        return ServiceConnectionProvider.createProxy(container, path, arg);
     }
 
     static createLocalProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): RpcProxy<T> {
-        return container.get<WebSocketConnectionProvider>(LocalWebSocketConnectionProvider).createProxy<T>(path, arg);
+        return ServiceConnectionProvider.createLocalProxy(container, path, arg);
     }
 
     static createHandler(container: interfaces.Container, path: string, arg?: object): void {
-        const remote = container.get(WebSocketConnectionProvider);
-        const local = container.get<WebSocketConnectionProvider>(LocalWebSocketConnectionProvider);
-        remote.createProxy(path, arg);
-        if (remote !== local) {
-            local.createProxy(path, arg);
-        }
+        return ServiceConnectionProvider.createHandler(container, path, arg);
     }
 
-    protected readonly socket: Socket;
-
-    constructor() {
-        super();
-        const url = this.createWebSocketUrl(WebSocketChannel.wsPath);
-        this.socket = this.createWebSocket(url);
-        this.socket.on('connect', () => {
-            this.initializeMultiplexer();
-            if (this.reconnectChannelOpeners.length > 0) {
-                this.reconnectChannelOpeners.forEach(opener => opener());
-                this.reconnectChannelOpeners = [];
-            }
-            this.socket.on('disconnect', () => this.fireSocketDidClose());
-            this.socket.on('message', () => this.onIncomingMessageActivityEmitter.fire(undefined));
-            this.fireSocketDidOpen();
-        });
-        this.socket.connect();
-    }
-
-    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) {
-            return super.openChannel(path, handler, options);
-        } else {
-            const openChannel = () => {
-                this.socket.off('connect', openChannel);
-                this.openChannel(path, handler, options);
-            };
-            this.socket.on('connect', openChannel);
-        }
-    }
-
-    /**
-     * @param path The handler to reach in the backend.
-     */
-    protected createWebSocketUrl(path: string): string {
-        // Since we are using Socket.io, the path should look like the following:
-        // proto://domain.com/{path}
-        return this.createEndpoint(path).getWebSocketUrl().withPath(path).toString();
-    }
-
-    protected createHttpWebSocketUrl(path: string): string {
-        return this.createEndpoint(path).getRestUrl().toString();
-    }
-
-    protected createEndpoint(path: string): Endpoint {
-        return new Endpoint({ path });
-    }
-
-    /**
-     * Creates a web socket for the given url
-     */
-    protected createWebSocket(url: string): Socket {
-        return io(url, {
-            path: this.createSocketIoPath(url),
-            reconnection: true,
-            reconnectionDelay: 1000,
-            reconnectionDelayMax: 10000,
-            reconnectionAttempts: Infinity,
-            extraHeaders: {
-                // Socket.io strips the `origin` header
-                // We need to provide our own for validation
-                'fix-origin': window.location.origin
-            }
-        });
-    }
-
-    /**
-     * Path for Socket.io to make its requests to.
-     */
-    protected createSocketIoPath(url: string): string | undefined {
-        if (location.protocol === Endpoint.PROTO_FILE) {
-            return '/socket.io';
-        }
-        let { pathname } = location;
-        if (!pathname.endsWith('/')) {
-            pathname += '/';
-        }
-        return pathname + 'socket.io';
-    }
-
-    protected fireSocketDidOpen(): void {
-        this.onSocketDidOpenEmitter.fire(undefined);
-    }
-
-    protected fireSocketDidClose(): void {
-        this.onSocketDidCloseEmitter.fire(undefined);
+    createProxy<T extends object>(path: string, target?: object): RpcProxy<T>;
+    createProxy<T extends object>(path: string, factory: RpcProxyFactory<T>): RpcProxy<T> {
+        return this.remoteConnectionProvider.createProxy(path, factory);
     }
 }
-

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

@@ -0,0 +1,210 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { AbstractChannel, Channel, Disposable, DisposableCollection, Emitter, Event, servicesPath } from '../../common';
+import { ConnectionSource } from './connection-source';
+import { Socket, io } from 'socket.io-client';
+import { Endpoint } from '../endpoint';
+import { ForwardingChannel } from '../../common/message-rpc/channel';
+import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
+import { inject, injectable, postConstruct } from 'inversify';
+import { FrontendIdProvider } from './frontend-id-provider';
+import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+import { SocketWriteBuffer } from '../../common/messaging/socket-write-buffer';
+import { ConnectionManagementMessages } from '../../common/messaging/connection-management';
+
+@injectable()
+export class WebSocketConnectionSource implements ConnectionSource {
+    static readonly NO_CONNECTION = '<none>';
+
+    @inject(FrontendIdProvider)
+    protected readonly frontendIdProvider: FrontendIdProvider;
+
+    private readonly writeBuffer = new SocketWriteBuffer();
+
+    private _socket: Socket;
+    get socket(): Socket {
+        return this._socket;
+    }
+
+    protected currentChannel: AbstractChannel;
+
+    protected readonly onConnectionDidOpenEmitter: Emitter<Channel> = new Emitter();
+    get onConnectionDidOpen(): Event<Channel> {
+        return this.onConnectionDidOpenEmitter.event;
+    }
+
+    protected readonly onSocketDidOpenEmitter: Emitter<void> = new Emitter();
+    get onSocketDidOpen(): Event<void> {
+        return this.onSocketDidOpenEmitter.event;
+    }
+
+    protected readonly onSocketDidCloseEmitter: Emitter<void> = new Emitter();
+    get onSocketDidClose(): Event<void> {
+        return this.onSocketDidCloseEmitter.event;
+    }
+
+    protected readonly onIncomingMessageActivityEmitter: Emitter<void> = new Emitter();
+    get onIncomingMessageActivity(): Event<void> {
+        return this.onIncomingMessageActivityEmitter.event;
+    }
+
+    constructor() {
+    }
+
+    @postConstruct()
+    openSocket(): void {
+        const url = this.createWebSocketUrl(servicesPath);
+        this._socket = this.createWebSocket(url);
+
+        this._socket.on('connect', () => {
+            this.onSocketDidOpenEmitter.fire();
+            this.handleSocketConnected();
+        });
+
+        this._socket.on('disconnect', () => {
+            this.onSocketDidCloseEmitter.fire();
+        });
+
+        this._socket.on('error', reason => {
+            if (this.currentChannel) {
+                this.currentChannel.onErrorEmitter.fire(reason);
+            };
+        });
+        this._socket.connect();
+    }
+
+    protected handleSocketConnected(): void {
+        if (this.currentChannel) {
+            const reconnectListener = (hasConnection: boolean) => {
+                this._socket.off(ConnectionManagementMessages.RECONNECT, reconnectListener);
+                if (hasConnection) {
+                    this.writeBuffer.flush(this.socket);
+                } else {
+                    if (FrontendApplicationConfigProvider.get().reloadOnReconnect) {
+                        window.location.reload(); // this might happen in the preload module, when we have no window service yet
+                    } else {
+                        this.connectNewChannel();
+                    }
+                }
+            };
+            this._socket.on(ConnectionManagementMessages.RECONNECT, reconnectListener);
+            this._socket.emit(ConnectionManagementMessages.RECONNECT, this.frontendIdProvider.getId());
+        } else {
+            const initialConnectListener = () => {
+                this._socket.off(ConnectionManagementMessages.INITIAL_CONNECT, initialConnectListener);
+                this.connectNewChannel();
+            };
+            this._socket.on(ConnectionManagementMessages.INITIAL_CONNECT, initialConnectListener);
+            this._socket.emit(ConnectionManagementMessages.INITIAL_CONNECT, this.frontendIdProvider.getId());
+        }
+    }
+
+    connectNewChannel(): void {
+        if (this.currentChannel) {
+            this.writeBuffer.drain();
+            this.currentChannel.close();
+            this.currentChannel.onCloseEmitter.fire({ reason: 'reconnecting channel' });
+        }
+        this.currentChannel = this.createChannel();
+        this.onConnectionDidOpenEmitter.fire(this.currentChannel);
+    }
+
+    protected createChannel(): AbstractChannel {
+        const toDispose = new DisposableCollection();
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const messageHandler = (data: any) => {
+            this.onIncomingMessageActivityEmitter.fire();
+            if (this.currentChannel) {
+                // In the browser context socketIO receives binary messages as ArrayBuffers.
+                // So we have to convert them to a Uint8Array before delegating the message to the read buffer.
+                const buffer = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+                this.currentChannel.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(buffer));
+            };
+        };
+        this._socket.on('message', messageHandler);
+        toDispose.push(Disposable.create(() => {
+            this.socket.off('message', messageHandler);
+        }));
+
+        const channel = new ForwardingChannel('any', () => {
+            toDispose.dispose();
+        }, () => {
+            const result = new Uint8ArrayWriteBuffer();
+
+            result.onCommit(buffer => {
+                if (this.socket.connected) {
+                    this.socket.send(buffer);
+                } else {
+                    this.writeBuffer.buffer(buffer);
+                }
+            });
+
+            return result;
+        });
+        return channel;
+    }
+
+    /**
+     * @param path The handler to reach in the backend.
+     */
+    protected createWebSocketUrl(path: string): string {
+        // Since we are using Socket.io, the path should look like the following:
+        // proto://domain.com/{path}
+        return this.createEndpoint(path).getWebSocketUrl().withPath(path).toString();
+    }
+
+    protected createHttpWebSocketUrl(path: string): string {
+        return this.createEndpoint(path).getRestUrl().toString();
+    }
+
+    protected createEndpoint(path: string): Endpoint {
+        return new Endpoint({ path });
+    }
+
+    /**
+     * Creates a web socket for the given url
+     */
+    protected createWebSocket(url: string): Socket {
+        return io(url, {
+            path: this.createSocketIoPath(url),
+            reconnection: true,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 10000,
+            reconnectionAttempts: Infinity,
+            extraHeaders: {
+                // Socket.io strips the `origin` header
+                // We need to provide our own for validation
+                'fix-origin': window.location.origin
+            }
+        });
+    }
+
+    /**
+     * Path for Socket.io to make its requests to.
+     */
+    protected createSocketIoPath(url: string): string | undefined {
+        if (location.protocol === Endpoint.PROTO_FILE) {
+            return '/socket.io';
+        }
+        let { pathname } = location;
+        if (!pathname.endsWith('/')) {
+            pathname += '/';
+        }
+        return pathname + 'socket.io';
+    }
+}

package/src/browser/preload/i18n-preload-contribution.ts

@@ -33,7 +33,7 @@ export class I18nPreloadContribution implements PreloadContribution {
                 locale: defaultLocale
             });
         }
-        if (nls.locale) {
+        if (nls.locale && nls.locale !== nls.defaultLocale) {
             const localization = await this.localizationServer.loadLocalization(nls.locale);
             if (localization.languagePack) {
                 nls.localization = localization;