@theia/plugin-ext 1.18.0-next.d3501165 → 1.19.0

package/src/common/plugin-protocol.ts

@@ -23,6 +23,7 @@ import { IJSONSchema, IJSONSchemaSnippet } from '@theia/core/lib/common/json-sch
 import { RecursivePartial } from '@theia/core/lib/common/types';
 import { PreferenceSchema, PreferenceSchemaProperties } from '@theia/core/lib/common/preferences/preference-schema';
 import { ProblemMatcherContribution, ProblemPatternContribution, TaskDefinition } from '@theia/task/lib/common';
+// eslint-disable-next-line @theia/runtime-import-check
 import { ColorDefinition } from '@theia/core/lib/browser/color-registry';
 import { ResourceLabelFormatter } from '@theia/core/lib/common/label-protocol';
 
@@ -554,6 +555,7 @@ export interface Localization {
 
 export interface Translation {
     id: string;
+    path: string;
     version: string;
     contents: { [scope: string]: { [key: string]: string } }
 }

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

@@ -25,13 +25,13 @@ import debounce = require('@theia/core/shared/lodash.debounce');
 import { UUID } from '@theia/core/shared/@phosphor/coreutils';
 import { injectable, inject, interfaces, named, postConstruct } from '@theia/core/shared/inversify';
 import { PluginWorker } from './plugin-worker';
-import { PluginMetadata, getPluginId, HostedPluginServer, DeployedPlugin } from '../../common/plugin-protocol';
+import { PluginMetadata, getPluginId, HostedPluginServer, DeployedPlugin, PluginServer } from '../../common/plugin-protocol';
 import { HostedPluginWatcher } from './hosted-plugin-watcher';
 import { MAIN_RPC_CONTEXT, PluginManagerExt, ConfigStorage, UIKind } from '../../common/plugin-api-rpc';
 import { setUpPluginApi } from '../../main/browser/main-context';
 import { RPCProtocol, RPCProtocolImpl } from '../../common/rpc-protocol';
 import {
-    Disposable, DisposableCollection,
+    Disposable, DisposableCollection, Emitter, isCancelled,
     ILogger, ContributionProvider, CommandRegistry, WillExecuteCommandEvent,
     CancellationTokenSource, JsonRpcProxy, ProgressService
 } from '@theia/core';
@@ -42,13 +42,11 @@ import { getQueryParameters } from '../../main/browser/env-main';
 import { MainPluginApiProvider } from '../../common/plugin-ext-api-contribution';
 import { PluginPathsService } from '../../main/common/plugin-paths-protocol';
 import { getPreferences } from '../../main/browser/preference-registry-main';
-import { PluginServer } from '../../common/plugin-protocol';
 import { Deferred } from '@theia/core/lib/common/promise-util';
 import { DebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
 import { DebugConfigurationManager } from '@theia/debug/lib/browser/debug-configuration-manager';
 import { WaitUntilEvent } from '@theia/core/lib/common/event';
 import { FileSearchService } from '@theia/file-search/lib/common/file-search-service';
-import { Emitter, isCancelled } from '@theia/core';
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
 import { PluginViewRegistry } from '../../main/browser/view/plugin-view-registry';
 import { TaskProviderRegistry, TaskResolverRegistry } from '@theia/task/lib/browser/task-contribution';
@@ -66,7 +64,7 @@ import { PluginCustomEditorRegistry } from '../../main/browser/custom-editors/pl
 import { CustomEditorWidget } from '../../main/browser/custom-editors/custom-editor-widget';
 
 export type PluginHost = 'frontend' | string;
-export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker';
+export type DebugActivationEvent = 'onDebugResolve' | 'onDebugInitialConfigurations' | 'onDebugAdapterProtocolTracker' | 'onDebugDynamicConfigurations';
 
 export const PluginProgressLocation = 'plugin';
 
@@ -198,6 +196,8 @@ export class HostedPluginSupport {
         this.debugSessionManager.onWillStartDebugSession(event => this.ensureDebugActivation(event));
         this.debugSessionManager.onWillResolveDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugResolve', event.debugType));
         this.debugConfigurationManager.onWillProvideDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugInitialConfigurations'));
+        // Activate all providers of dynamic configurations, i.e. Let the user pick a configuration from all the available ones.
+        this.debugConfigurationManager.onWillProvideDynamicDebugConfiguration(event => this.ensureDebugActivation(event, 'onDebugDynamicConfigurations', '*'));
         this.viewRegistry.onDidExpandView(id => this.activateByView(id));
         this.taskProviderRegistry.onWillProvideTaskProvider(event => this.ensureTaskActivation(event));
         this.taskResolverRegistry.onWillProvideTaskResolver(event => this.ensureTaskActivation(event));
@@ -302,12 +302,15 @@ export class HostedPluginSupport {
      */
     protected async syncPlugins(): Promise<void> {
         let initialized = 0;
-        const syncPluginsMeasurement = this.createMeasurement('syncPlugins');
+        const waitPluginsMeasurement = this.createMeasurement('waitForDeployment');
+        let syncPluginsMeasurement: () => number;
 
         const toUnload = new Set(this.contributions.keys());
         try {
             const pluginIds: string[] = [];
             const deployedPluginIds = await this.server.getDeployedPluginIds();
+            this.logMeasurement('Waiting for backend deployment', waitPluginsMeasurement);
+            syncPluginsMeasurement = this.createMeasurement('syncPlugins');
             for (const pluginId of deployedPluginIds) {
                 toUnload.delete(pluginId);
                 if (!this.contributions.has(pluginId)) {
@@ -336,7 +339,7 @@ export class HostedPluginSupport {
             }
         }
 
-        this.logMeasurement('Sync', initialized, syncPluginsMeasurement);
+        this.logMeasurement(`Sync of ${this.getPluginCount(initialized)}`, syncPluginsMeasurement);
     }
 
     /**
@@ -374,7 +377,7 @@ export class HostedPluginSupport {
             }
         }
 
-        this.logMeasurement('Load contributions', loaded, loadPluginsMeasurement);
+        this.logMeasurement(`Load contributions of ${this.getPluginCount(loaded)}`, loadPluginsMeasurement);
 
         return hostContributions;
     }
@@ -444,7 +447,7 @@ export class HostedPluginSupport {
             return;
         }
 
-        this.logMeasurement('Start', started, startPluginsMeasurement);
+        this.logMeasurement(`Start of ${this.getPluginCount(started)}`, startPluginsMeasurement);
     }
 
     protected async obtainManager(host: string, hostContributions: PluginContributions[], toDisconnect: DisposableCollection): Promise<PluginManagerExt | undefined> {
@@ -712,15 +715,19 @@ export class HostedPluginSupport {
         };
     }
 
-    protected logMeasurement(prefix: string, count: number, measurement: () => number): void {
+    protected logMeasurement(measurementName: string, measurement: () => number): void {
         const duration = measurement();
         if (duration === Number.NaN) {
             // Measurement was prevented by native API, do not log NaN duration
             return;
         }
 
-        const pluginCount = `${count} plugin${count === 1 ? '' : 's'}`;
-        console.log(`[${this.clientId}] ${prefix} of ${pluginCount} took: ${duration.toFixed(1)} ms`);
+        const timeFromFrontendStart = `Finished ${(performance.now() / 1000).toFixed(3)} s after frontend start`;
+        console.log(`[${this.clientId}] ${measurementName} took: ${duration.toFixed(1)} ms [${timeFromFrontendStart}]`);
+    }
+
+    protected getPluginCount(plugins: number): string {
+        return `${plugins} plugin${plugins === 1 ? '' : 's'}`;
     }
 
     protected readonly webviewsToRestore = new Set<WebviewWidget>();

package/src/hosted/browser/worker/debug-stub.ts

@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
+// eslint-disable-next-line @theia/runtime-import-check
 import { DebugExtImpl } from '../../../plugin/node/debug/debug';
 import { RPCProtocol } from '../../../common/rpc-protocol';
 

package/src/hosted/node/hosted-plugin-deployer-handler.ts

@@ -17,11 +17,11 @@
 import * as fs from '@theia/core/shared/fs-extra';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { ILogger } from '@theia/core';
-import { PluginDeployerHandler, PluginDeployerEntry, PluginEntryPoint, DeployedPlugin, PluginDependencies, Localization } from '../../common/plugin-protocol';
+import { PluginDeployerHandler, PluginDeployerEntry, PluginEntryPoint, DeployedPlugin, PluginDependencies, PluginType } from '../../common/plugin-protocol';
 import { HostedPluginReader } from './plugin-reader';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
-import { Localization as TheiaLocalization } from '@theia/core/lib/common/i18n/localization';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
+import { BackendApplicationConfigProvider } from '@theia/core/lib/node/backend-application-config-provider';
 
 @injectable()
 export class HostedPluginDeployerHandler implements PluginDeployerHandler {
@@ -32,8 +32,8 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
     @inject(HostedPluginReader)
     private readonly reader: HostedPluginReader;
 
-    @inject(LocalizationProvider)
-    private readonly localizationProvider: LocalizationProvider;
+    @inject(HostedPluginLocalizationService)
+    private readonly localizationService: HostedPluginLocalizationService;
 
     private readonly deployedLocations = new Map<string, Set<string>>();
 
@@ -85,7 +85,11 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             }
             const metadata = this.reader.readMetadata(manifest);
             const dependencies: PluginDependencies = { metadata };
-            dependencies.mapping = this.reader.readDependencies(manifest);
+            // Do not resolve system (aka builtin) plugins because it should be done statically at build time.
+            const { resolveSystemPlugins = true } = BackendApplicationConfigProvider.get();
+            if (resolveSystemPlugins || entry.type !== PluginType.System) {
+                dependencies.mapping = this.reader.readDependencies(manifest);
+            }
             return dependencies;
         } catch (e) {
             console.error(`Failed to load plugin dependencies from '${pluginPath}' path`, e);
@@ -105,6 +109,8 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         for (const plugin of backendPlugins) {
             await this.deployPlugin(plugin, 'backend');
         }
+        // rebuild translation config after deployment
+        this.localizationService.buildTranslationConfig([...this.deployedBackendPlugins.values()]);
         // resolve on first deploy
         this.backendPluginsMetadataDeferred.resolve(undefined);
     }
@@ -134,9 +140,7 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
             const { type } = entry;
             const deployed: DeployedPlugin = { metadata, type };
             deployed.contributes = this.reader.readContribution(manifest);
-            if (deployed.contributes?.localizations) {
-                this.localizationProvider.addLocalizations(...buildTheiaLocalizations(deployed.contributes.localizations));
-            }
+            this.localizationService.deployLocalizations(deployed);
             deployedPlugins.set(metadata.model.id, deployed);
             this.logger.info(`Deploying ${entryPoint} plugin "${metadata.model.name}@${metadata.model.version}" from "${metadata.model.entryPoint[entryPoint] || pluginPath}"`);
         } catch (e) {
@@ -162,34 +166,3 @@ export class HostedPluginDeployerHandler implements PluginDeployerHandler {
         return true;
     }
 }
-
-function buildTheiaLocalizations(localizations: Localization[]): TheiaLocalization[] {
-    const theiaLocalizations: TheiaLocalization[] = [];
-    for (const localization of localizations) {
-        const theiaLocalization: TheiaLocalization = {
-            languageId: localization.languageId,
-            languageName: localization.languageName,
-            localizedLanguageName: localization.localizedLanguageName,
-            languagePack: true,
-            translations: {}
-        };
-        for (const translation of localization.translations) {
-            for (const [scope, value] of Object.entries(translation.contents)) {
-                for (const [key, item] of Object.entries(value)) {
-                    const translationKey = buildTheiaTranslationKey(translation.id, scope, key);
-                    theiaLocalization.translations[translationKey] = item;
-                }
-            }
-        }
-        theiaLocalizations.push(theiaLocalization);
-    }
-    return theiaLocalizations;
-}
-
-function buildTheiaTranslationKey(pluginId: string, scope: string, key: string): string {
-    const scopeSlashIndex = scope.lastIndexOf('/');
-    if (scopeSlashIndex >= 0) {
-        scope = scope.substring(scopeSlashIndex + 1);
-    }
-    return `${pluginId}/${scope}/${key}`;
-}

package/src/hosted/node/hosted-plugin-localization-service.ts

@@ -0,0 +1,201 @@
+/********************************************************************************
+ * Copyright (C) 2021 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 * as path from 'path';
+import * as fs from '@theia/core/shared/fs-extra';
+import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
+import { Localization } from '@theia/core/lib/common/i18n/localization';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { DeployedPlugin, Localization as PluginLocalization, PluginContribution } from '../../common';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+
+export interface VSCodeNlsConfig {
+    locale: string
+    availableLanguages: Record<string, string>
+    _languagePackSupport?: boolean
+    _languagePackId?: string
+    _translationsConfigFile?: string
+    _cacheRoot?: string
+    _corruptedFile?: string
+}
+
+@injectable()
+export class HostedPluginLocalizationService {
+
+    @inject(LocalizationProvider)
+    protected readonly localizationProvider: LocalizationProvider;
+
+    @inject(EnvVariablesServer)
+    protected readonly envVariables: EnvVariablesServer;
+
+    protected translationConfigFiles: Map<string, string> = new Map();
+
+    deployLocalizations(plugin: DeployedPlugin): void {
+        if (plugin.contributes?.localizations) {
+            this.localizationProvider.addLocalizations(...buildLocalizations(plugin.contributes.localizations));
+        }
+    }
+
+    async localizePlugin(plugin: DeployedPlugin): Promise<DeployedPlugin> {
+        const currentLanguage = this.localizationProvider.getCurrentLanguage();
+        const localization = this.localizationProvider.loadLocalization(currentLanguage);
+        const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
+        const pluginId = plugin.metadata.model.id;
+        // create a shallow copy to not override the original plugin's contributes property.
+        const shallowCopy = { ...plugin };
+        try {
+            const translations = await loadPackageTranslations(pluginPath, currentLanguage);
+            shallowCopy.contributes = localizePackage(shallowCopy.contributes, translations, (key, original) => {
+                const fullKey = `${pluginId}/package/${key}`;
+                return Localization.localize(localization, fullKey, original);
+            }) as PluginContribution;
+        } catch (err) {
+            console.error(`Failed to localize plugin '${pluginId}'.`, err);
+        }
+        return shallowCopy;
+    }
+
+    getNlsConfig(): VSCodeNlsConfig {
+        const locale = this.localizationProvider.getCurrentLanguage();
+        const configFile = this.translationConfigFiles.get(locale);
+        if (locale === 'en' || !configFile) {
+            return { locale, availableLanguages: {} };
+        }
+        const cache = path.dirname(configFile);
+        return {
+            locale,
+            availableLanguages: { '*': locale },
+            _languagePackSupport: true,
+            _cacheRoot: cache,
+            _languagePackId: locale,
+            _translationsConfigFile: configFile
+        };
+    }
+
+    async buildTranslationConfig(plugins: DeployedPlugin[]): Promise<void> {
+        const configDir = URI.parse(await this.envVariables.getConfigDirUri()).fsPath;
+        const cacheDir = path.join(configDir, 'localization-cache');
+        const configs = new Map<string, Record<string, string>>();
+        for (const plugin of plugins) {
+            if (plugin.contributes?.localizations) {
+                const pluginPath = URI.parse(plugin.metadata.model.packageUri).fsPath;
+                for (const localization of plugin.contributes.localizations) {
+                    const config = configs.get(localization.languageId) || {};
+                    for (const translation of localization.translations) {
+                        const fullPath = path.join(pluginPath, translation.path);
+                        config[translation.id] = fullPath;
+                    }
+                    configs.set(localization.languageId, config);
+                }
+            }
+        }
+
+        for (const [language, config] of configs.entries()) {
+            const languageConfigDir = path.join(cacheDir, language);
+            await fs.mkdirs(languageConfigDir);
+            const configFile = path.join(languageConfigDir, `nls.config.${language}.json`);
+            this.translationConfigFiles.set(language, configFile);
+            await fs.writeJson(configFile, config);
+        }
+    }
+}
+
+function buildLocalizations(localizations: PluginLocalization[]): Localization[] {
+    const theiaLocalizations: Localization[] = [];
+    for (const localization of localizations) {
+        const theiaLocalization: Localization = {
+            languageId: localization.languageId,
+            languageName: localization.languageName,
+            localizedLanguageName: localization.localizedLanguageName,
+            languagePack: true,
+            translations: {}
+        };
+        for (const translation of localization.translations) {
+            for (const [scope, value] of Object.entries(translation.contents)) {
+                for (const [key, item] of Object.entries(value)) {
+                    const translationKey = buildTranslationKey(translation.id, scope, key);
+                    theiaLocalization.translations[translationKey] = item;
+                }
+            }
+        }
+        theiaLocalizations.push(theiaLocalization);
+    }
+    return theiaLocalizations;
+}
+
+function buildTranslationKey(pluginId: string, scope: string, key: string): string {
+    return `${pluginId}/${Localization.transformKey(scope)}/${key}`;
+}
+
+interface PackageTranslation {
+    translation?: Record<string, string>
+    default?: Record<string, string>
+}
+
+async function loadPackageTranslations(pluginPath: string, locale: string): Promise<PackageTranslation> {
+    const localizedPluginPath = path.join(pluginPath, `package.nls.${locale}.json`);
+    try {
+        const defaultValue = await fs.readJson(path.join(pluginPath, 'package.nls.json'));
+        if (await fs.pathExists(localizedPluginPath)) {
+            return {
+                translation: await fs.readJson(localizedPluginPath),
+                default: defaultValue
+            };
+        }
+        return {
+            default: defaultValue
+        };
+    } catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+        return {};
+    }
+}
+
+const NLS_REGEX = /^%([\w\d.-]+)%$/i;
+
+function localizePackage(value: unknown, translations: PackageTranslation, callback: (key: string, defaultValue: string) => string): unknown {
+    if (typeof value === 'string') {
+        const match = NLS_REGEX.exec(value);
+        let result = value;
+        if (match) {
+            const key = match[1];
+            if (translations.translation) {
+                result = translations.translation[key];
+            } else if (translations.default) {
+                result = callback(key, translations.default[key]);
+            }
+        }
+        return result;
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        for (const item of value) {
+            result.push(localizePackage(item, translations, callback));
+        }
+        return result;
+    }
+    if (typeof value === 'object' && value) {
+        const result: Record<string, unknown> = {};
+        for (const [name, item] of Object.entries(value)) {
+            result[name] = localizePackage(item, translations, callback);
+        }
+        return result;
+    }
+    return value;
+}

package/src/hosted/node/hosted-plugin-process.ts

@@ -23,7 +23,7 @@ import { MessageType } from '../../common/rpc-protocol';
 import { HostedPluginCliContribution } from './hosted-plugin-cli-contribution';
 import * as psTree from 'ps-tree';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 
 export interface IPCConnectionOptions {
     readonly serverName: string;
@@ -56,8 +56,8 @@ export class HostedPluginProcess implements ServerPluginRunner {
     @inject(MessageService)
     protected readonly messageService: MessageService;
 
-    @inject(LocalizationProvider)
-    protected readonly localizationProvider: LocalizationProvider;
+    @inject(HostedPluginLocalizationService)
+    protected readonly localizationService: HostedPluginLocalizationService;
 
     private childProcess: cp.ChildProcess | undefined;
     private client: HostedPluginClient;
@@ -173,9 +173,7 @@ export class HostedPluginProcess implements ServerPluginRunner {
                 delete env[key];
             }
         }
-        const availableLanguages = ['en', ...this.localizationProvider.getAvailableLanguages()];
-        const locale = this.localizationProvider.getCurrentLanguage();
-        env['VSCODE_NLS_CONFIG'] = JSON.stringify({ locale, availableLanguages });
+        env['VSCODE_NLS_CONFIG'] = JSON.stringify(this.localizationService.getNlsConfig());
         // apply external env variables
         this.pluginHostEnvironmentVariables.getContributions().forEach(envVar => envVar.process(env));
         if (this.cli.extensionTestsPath) {

package/src/hosted/node/plugin-ext-hosted-backend-module.ts

@@ -33,6 +33,7 @@ import { HostedPluginCliContribution } from './hosted-plugin-cli-contribution';
 import { HostedPluginDeployerHandler } from './hosted-plugin-deployer-handler';
 import { PluginUriFactory } from './scanners/plugin-uri-factory';
 import { FilePluginUriFactory } from './scanners/file-plugin-uri-factory';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 
 const commonHostedConnectionModule = ConnectionContainerModule.create(({ bind, bindBackendService }) => {
     bind(HostedPluginProcess).toSelf().inSingletonScope();
@@ -58,6 +59,7 @@ export function bindCommonHostedBackend(bind: interfaces.Bind): void {
     bind(HostedPluginReader).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(HostedPluginReader);
 
+    bind(HostedPluginLocalizationService).toSelf().inSingletonScope();
     bind(HostedPluginDeployerHandler).toSelf().inSingletonScope();
     bind(PluginDeployerHandler).toService(HostedPluginDeployerHandler);
 

package/src/hosted/node/plugin-manifest-loader.ts

@@ -14,68 +14,16 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
 
-const NLS_REGEX = /^%([\w\d.-]+)%$/i;
-
-export async function loadManifest(pluginPath: string, locale?: string): Promise<any> {
-    const [manifest, translations] = await Promise.all([
-        fs.readJson(path.join(pluginPath, 'package.json')),
-        loadTranslations(pluginPath, locale)
-    ]);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function loadManifest(pluginPath: string): Promise<any> {
+    const manifest = await fs.readJson(path.join(pluginPath, 'package.json'));
     // translate vscode builtins, as they are published with a prefix. See https://github.com/theia-ide/vscode-builtin-extensions/blob/master/src/republish.js#L50
     const built_prefix = '@theia/vscode-builtin-';
     if (manifest && manifest.name && manifest.name.startsWith(built_prefix)) {
         manifest.name = manifest.name.substr(built_prefix.length);
     }
-    return manifest && translations && Object.keys(translations).length ?
-        localize(manifest, translations) :
-        manifest;
-}
-
-async function loadTranslations(pluginPath: string, locale?: string): Promise<any> {
-    try {
-        const localizedPluginPath = path.join(pluginPath, `package.nls.${locale}.json`);
-        if (await fs.pathExists(localizedPluginPath)) {
-            return await fs.readJson(localizedPluginPath);
-        } else {
-            return await fs.readJson(path.join(pluginPath, 'package.nls.json'));
-        }
-    } catch (e) {
-        if (e.code !== 'ENOENT') {
-            throw e;
-        }
-        return {};
-    }
-}
-
-function localize(value: any, translations: {
-    [key: string]: string
-}): any {
-    if (typeof value === 'string') {
-        const match = NLS_REGEX.exec(value);
-        return match && translations[match[1]] || value;
-    }
-    if (Array.isArray(value)) {
-        const result = [];
-        for (const item of value) {
-            result.push(localize(item, translations));
-        }
-        return result;
-    }
-    if (value === null) {
-        return value;
-    }
-    if (typeof value === 'object') {
-        const result: { [key: string]: any } = {};
-        // eslint-disable-next-line guard-for-in
-        for (const propertyName in value) {
-            result[propertyName] = localize(value[propertyName], translations);
-        }
-        return result;
-    }
-    return value;
+    return manifest;
 }

package/src/hosted/node/plugin-service.ts

@@ -16,13 +16,11 @@
 import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
 import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin } from '../../common/plugin-protocol';
 import { HostedPluginSupport } from './hosted-plugin';
-import { ILogger, Disposable } from '@theia/core';
-import { ContributionProvider } from '@theia/core';
+import { ILogger, Disposable, ContributionProvider } from '@theia/core';
 import { ExtPluginApiProvider, ExtPluginApi } from '../../common/plugin-ext-api-contribution';
 import { HostedPluginDeployerHandler } from './hosted-plugin-deployer-handler';
 import { PluginDeployerImpl } from '../../main/node/plugin-deployer-impl';
-import { LocalizationProvider } from '@theia/core/lib/node/i18n/localization-provider';
-import { loadManifest } from './plugin-manifest-loader';
+import { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
 
 @injectable()
 export class HostedPluginServerImpl implements HostedPluginServer {
@@ -35,8 +33,8 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     @inject(PluginDeployer)
     protected readonly pluginDeployer: PluginDeployerImpl;
 
-    @inject(LocalizationProvider)
-    protected readonly localizationProvider: LocalizationProvider;
+    @inject(HostedPluginLocalizationService)
+    protected readonly localizationService: HostedPluginLocalizationService;
 
     @inject(ContributionProvider)
     @named(Symbol.for(ExtPluginApiProvider))
@@ -90,8 +88,7 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         if (!pluginIds.length) {
             return [];
         }
-        const locale = this.localizationProvider.getCurrentLanguage();
-        const plugins = [];
+        const plugins: DeployedPlugin[] = [];
         let extraDeployedPlugins: Map<string, DeployedPlugin> | undefined;
         for (const pluginId of pluginIds) {
             let plugin = this.deployerHandler.getDeployedPlugin(pluginId);
@@ -105,10 +102,10 @@ export class HostedPluginServerImpl implements HostedPluginServer {
                 plugin = extraDeployedPlugins.get(pluginId);
             }
             if (plugin) {
-                plugins.push(await this.localizePlugin(plugin, locale));
+                plugins.push(plugin);
             }
         }
-        return plugins;
+        return Promise.all(plugins.map(plugin => this.localizationService.localizePlugin(plugin)));
     }
 
     onMessage(pluginHostId: string, message: string): Promise<void> {
@@ -119,34 +116,4 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     getExtPluginAPI(): Promise<ExtPluginApi[]> {
         return Promise.resolve(this.extPluginAPIContributions.getContributions().map(p => p.provideApi()));
     }
-
-    protected async localizePlugin(plugin: DeployedPlugin, locale: string): Promise<DeployedPlugin> {
-        const packagePath = plugin.metadata.model.packagePath;
-        const translatedManifest = await loadManifest(packagePath, locale);
-        this.mergeContributes(plugin.contributes, translatedManifest.contributes);
-        return plugin;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    protected mergeContributes(main: any, other: any): void {
-        if (main && other) {
-            if (Array.isArray(main) && Array.isArray(other)) {
-                for (let i = 0; i < main.length && i < other.length; i++) {
-                    if (typeof main[i] === 'object' && typeof other[i] === 'object') {
-                        this.mergeContributes(main[i], other[i]);
-                    }
-                }
-            } else {
-                for (const [key, value] of Object.entries(main)) {
-                    if (key in other) {
-                        if (typeof value === 'string') {
-                            main[key] = other[key];
-                        } else if (typeof value === 'object' && typeof other[key] === 'object') {
-                            this.mergeContributes(main[key], other[key]);
-                        }
-                    }
-                }
-            }
-        }
-    }
 }