@theia/plugin-ext 1.27.0-next.7 → 1.27.0-next.72

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

@@ -16,7 +16,7 @@
 
 import { injectable, inject, multiInject, postConstruct, optional } from '@theia/core/shared/inversify';
 import { ILogger, ConnectionErrorHandler } from '@theia/core/lib/common';
-import { HostedPluginClient, PluginModel, ServerPluginRunner, DeployedPlugin } from '../../common/plugin-protocol';
+import { HostedPluginClient, PluginModel, ServerPluginRunner, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
 import { LogPart } from '../../common/types';
 import { HostedPluginProcess } from './hosted-plugin-process';
 
@@ -95,7 +95,7 @@ export class HostedPluginSupport {
     /**
      * Provides additional plugin ids.
      */
-    async getExtraDeployedPluginIds(): Promise<string[]> {
+    async getExtraDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         return [].concat.apply([], await Promise.all(this.pluginRunners.map(runner => runner.getExtraDeployedPluginIds())));
     }
 

package/src/hosted/node/metadata-scanner.ts

@@ -14,15 +14,16 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, multiInject } from '@theia/core/shared/inversify';
-import { PluginPackage, PluginScanner, PluginMetadata, PLUGIN_HOST_BACKEND } from '../../common/plugin-protocol';
+import { inject, injectable, multiInject } from '@theia/core/shared/inversify';
+import { PluginPackage, PluginScanner, PluginMetadata, PLUGIN_HOST_BACKEND, PluginIdentifiers } from '../../common/plugin-protocol';
+import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
 @injectable()
 export class MetadataScanner {
     private scanners: Map<string, PluginScanner> = new Map();
 
-    constructor( // eslint-disable-next-line @typescript-eslint/indent
-        @multiInject(PluginScanner) scanners: PluginScanner[]
-    ) {
+    @inject(PluginUninstallationManager) protected readonly uninstallationManager: PluginUninstallationManager;
+
+    constructor(@multiInject(PluginScanner) scanners: PluginScanner[]) {
         scanners.forEach((scanner: PluginScanner) => {
             this.scanners.set(scanner.apiType, scanner);
         });
@@ -33,7 +34,8 @@ export class MetadataScanner {
         return {
             host: PLUGIN_HOST_BACKEND,
             model: scanner.getModel(plugin),
-            lifecycle: scanner.getLifecycle(plugin)
+            lifecycle: scanner.getLifecycle(plugin),
+            outOfSync: this.uninstallationManager.isUninstalled(PluginIdentifiers.componentsToVersionedId(plugin)),
         };
     }
 

package/src/hosted/node/plugin-host-rpc.ts

@@ -22,7 +22,7 @@ import { createAPIFactory } from '../../plugin/plugin-context';
 import { EnvExtImpl } from '../../plugin/env';
 import { PreferenceRegistryExtImpl } from '../../plugin/preference-registry';
 import { ExtPluginApi, ExtPluginApiBackendInitializationFn } from '../../common/plugin-ext-api-contribution';
-import { DebugExtImpl } from '../../plugin/node/debug/debug';
+import { DebugExtImpl } from '../../plugin/debug/debug-ext';
 import { EditorsAndDocumentsExtImpl } from '../../plugin/editors-and-documents';
 import { WorkspaceExtImpl } from '../../plugin/workspace';
 import { MessageRegistryExt } from '../../plugin/message-registry';
@@ -114,7 +114,7 @@ export class PluginHostRPC {
                 console.log('PLUGIN_HOST(' + process.pid + '): PluginManagerExtImpl/loadPlugin(' + plugin.pluginPath + ')');
                 // cleaning the cache for all files of that plug-in.
                 Object.keys(require.cache).forEach(function (key): void {
-                    const mod: NodeJS.Module = require.cache[key];
+                    const mod: NodeJS.Module = require.cache[key]!;
 
                     // attempting to reload a native module will throw an error, so skip them
                     if (mod.id.endsWith('.node')) {

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

@@ -16,6 +16,7 @@
 
 import * as path from 'path';
 import * as fs from '@theia/core/shared/fs-extra';
+import { PluginIdentifiers } from '../../common';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export async function loadManifest(pluginPath: string): Promise<any> {
@@ -25,5 +26,6 @@ export async function loadManifest(pluginPath: string): Promise<any> {
     if (manifest && manifest.name && manifest.name.startsWith(built_prefix)) {
         manifest.name = manifest.name.substr(built_prefix.length);
     }
+    manifest.publisher ??= PluginIdentifiers.UNPUBLISHED;
     return manifest;
 }

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

@@ -14,13 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 import { injectable, inject, named, postConstruct } from '@theia/core/shared/inversify';
-import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin } from '../../common/plugin-protocol';
+import { HostedPluginServer, HostedPluginClient, PluginDeployer, GetDeployedPluginsParams, DeployedPlugin, PluginIdentifiers } from '../../common/plugin-protocol';
 import { HostedPluginSupport } from './hosted-plugin';
-import { ILogger, Disposable, ContributionProvider } from '@theia/core';
+import { ILogger, Disposable, ContributionProvider, DisposableCollection } 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 { HostedPluginLocalizationService } from './hosted-plugin-localization-service';
+import { PluginUninstallationManager } from '../../main/node/plugin-uninstallation-manager';
 
 @injectable()
 export class HostedPluginServerImpl implements HostedPluginServer {
@@ -40,9 +41,21 @@ export class HostedPluginServerImpl implements HostedPluginServer {
     @named(Symbol.for(ExtPluginApiProvider))
     protected readonly extPluginAPIContributions: ContributionProvider<ExtPluginApiProvider>;
 
+    @inject(PluginUninstallationManager) protected readonly uninstallationManager: PluginUninstallationManager;
+
     protected client: HostedPluginClient | undefined;
+    protected toDispose = new DisposableCollection();
+
+    protected _ignoredPlugins?: Set<PluginIdentifiers.VersionedId>;
+    // We ignore any plugins that are marked as uninstalled the first time the frontend requests information about deployed plugins.
+    protected get ignoredPlugins(): Set<PluginIdentifiers.VersionedId> {
+        if (!this._ignoredPlugins) {
+            this._ignoredPlugins = new Set(this.uninstallationManager.getUninstalledPluginIds());
+        }
+        return this._ignoredPlugins;
+    }
 
-    protected deployedListener: Disposable;
+    protected readonly pluginVersions = new Map<PluginIdentifiers.UnversionedId, string>();
 
     constructor(
         @inject(HostedPluginSupport) private readonly hostedPlugin: HostedPluginSupport) {
@@ -50,38 +63,78 @@ export class HostedPluginServerImpl implements HostedPluginServer {
 
     @postConstruct()
     protected init(): void {
-        this.deployedListener = this.pluginDeployer.onDidDeploy(() => {
-            if (this.client) {
-                this.client.onDidDeploy();
-            }
-        });
+        this.toDispose.pushAll([
+            this.pluginDeployer.onDidDeploy(() => this.client?.onDidDeploy()),
+            this.uninstallationManager.onDidChangeUninstalledPlugins(currentUninstalled => {
+                if (this._ignoredPlugins) {
+                    const uninstalled = new Set(currentUninstalled);
+                    for (const previouslyUninstalled of this._ignoredPlugins) {
+                        if (!uninstalled.has(previouslyUninstalled)) {
+                            this._ignoredPlugins.delete(previouslyUninstalled);
+                        }
+                    }
+                }
+                this.client?.onDidDeploy();
+            }),
+            Disposable.create(() => this.hostedPlugin.clientClosed()),
+        ]);
     }
 
     dispose(): void {
-        this.hostedPlugin.clientClosed();
-        this.deployedListener.dispose();
+        this.toDispose.dispose();
     }
+
     setClient(client: HostedPluginClient): void {
         this.client = client;
         this.hostedPlugin.setClient(client);
     }
 
-    async getDeployedPluginIds(): Promise<string[]> {
+    async getDeployedPluginIds(): Promise<PluginIdentifiers.VersionedId[]> {
         const backendMetadata = await this.deployerHandler.getDeployedBackendPluginIds();
         if (backendMetadata.length > 0) {
             this.hostedPlugin.runPluginServer();
         }
-        const plugins = new Set<string>();
-        for (const pluginId of await this.deployerHandler.getDeployedFrontendPluginIds()) {
-            plugins.add(pluginId);
+        const plugins = new Set<PluginIdentifiers.VersionedId>();
+        const addIds = async (identifiers: PluginIdentifiers.VersionedId[]): Promise<void> => {
+            for (const pluginId of identifiers) {
+                if (this.isRelevantPlugin(pluginId)) {
+                    plugins.add(pluginId);
+                }
+            }
+        };
+        addIds(await this.deployerHandler.getDeployedFrontendPluginIds());
+        addIds(backendMetadata);
+        addIds(await this.hostedPlugin.getExtraDeployedPluginIds());
+        return Array.from(plugins);
+    }
+
+    /**
+     * Ensures that the plugin was not uninstalled when this session was started
+     * and that it matches the first version of the given plugin seen by this session.
+     *
+     * The deployment system may have multiple versions of the same plugin available, but
+     * a single session should only ever activate one of them.
+     */
+    protected isRelevantPlugin(identifier: PluginIdentifiers.VersionedId): boolean {
+        const versionAndId = PluginIdentifiers.idAndVersionFromVersionedId(identifier);
+        if (!versionAndId) {
+            return false;
         }
-        for (const pluginId of backendMetadata) {
-            plugins.add(pluginId);
+        const knownVersion = this.pluginVersions.get(versionAndId.id);
+        if (knownVersion !== undefined && knownVersion !== versionAndId.version) {
+            return false;
         }
-        for (const pluginId of await this.hostedPlugin.getExtraDeployedPluginIds()) {
-            plugins.add(pluginId);
+        if (this.ignoredPlugins.has(identifier)) {
+            return false;
         }
-        return [...plugins.values()];
+        if (knownVersion === undefined) {
+            this.pluginVersions.set(versionAndId.id, versionAndId.version);
+        }
+        return true;
+    }
+
+    getUninstalledPluginIds(): Promise<readonly PluginIdentifiers.VersionedId[]> {
+        return Promise.resolve(this.uninstallationManager.getUninstalledPluginIds());
     }
 
     async getDeployedPlugins({ pluginIds }: GetDeployedPluginsParams): Promise<DeployedPlugin[]> {
@@ -90,16 +143,19 @@ export class HostedPluginServerImpl implements HostedPluginServer {
         }
         const plugins: DeployedPlugin[] = [];
         let extraDeployedPlugins: Map<string, DeployedPlugin> | undefined;
-        for (const pluginId of pluginIds) {
-            let plugin = this.deployerHandler.getDeployedPlugin(pluginId);
+        for (const versionedId of pluginIds) {
+            if (!this.isRelevantPlugin(versionedId)) {
+                continue;
+            }
+            let plugin = this.deployerHandler.getDeployedPlugin(versionedId);
             if (!plugin) {
                 if (!extraDeployedPlugins) {
                     extraDeployedPlugins = new Map<string, DeployedPlugin>();
                     for (const extraDeployedPlugin of await this.hostedPlugin.getExtraDeployedPlugins()) {
-                        extraDeployedPlugins.set(extraDeployedPlugin.metadata.model.id, extraDeployedPlugin);
+                        extraDeployedPlugins.set(PluginIdentifiers.componentsToVersionedId(extraDeployedPlugin.metadata.model), extraDeployedPlugin);
                     }
                 }
-                plugin = extraDeployedPlugins.get(pluginId);
+                plugin = extraDeployedPlugins.get(versionedId);
             }
             if (plugin) {
                 plugins.push(plugin);

package/src/hosted/node/scanners/scanner-theia.ts

@@ -58,7 +58,8 @@ import {
     PluginPackageLocalization,
     Localization,
     PluginPackageTranslation,
-    Translation
+    Translation,
+    PluginIdentifiers
 } from '../../../common/plugin-protocol';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -109,13 +110,14 @@ export class TheiaPluginScanner implements PluginScanner {
     }
 
     getModel(plugin: PluginPackage): PluginModel {
+        const publisher = plugin.publisher ?? PluginIdentifiers.UNPUBLISHED;
         const result: PluginModel = {
             packagePath: plugin.packagePath,
             packageUri: this.pluginUriFactory.createUri(plugin).toString(),
             // see id definition: https://github.com/microsoft/vscode/blob/15916055fe0cb9411a5f36119b3b012458fe0a1d/src/vs/platform/extensions/common/extensions.ts#L167-L169
-            id: `${plugin.publisher.toLowerCase()}.${plugin.name.toLowerCase()}`,
+            id: `${publisher.toLowerCase()}.${plugin.name.toLowerCase()}`,
             name: plugin.name,
-            publisher: plugin.publisher,
+            publisher,
             version: plugin.version,
             displayName: plugin.displayName,
             description: plugin.description,
@@ -660,7 +662,8 @@ export class TheiaPluginScanner implements PluginScanner {
                     wordPattern: rawConfiguration.wordPattern,
                     autoClosingPairs: this.extractValidAutoClosingPairs(rawLang.id, rawConfiguration),
                     indentationRules: rawConfiguration.indentationRules,
-                    surroundingPairs: this.extractValidSurroundingPairs(rawLang.id, rawConfiguration)
+                    surroundingPairs: this.extractValidSurroundingPairs(rawLang.id, rawConfiguration),
+                    onEnterRules: rawConfiguration.onEnterRules,
                 };
                 result.configuration = configuration;
             }

package/src/main/browser/custom-editors/custom-editor-opener.tsx

@@ -18,10 +18,10 @@ import { inject } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { ApplicationShell, OpenHandler, Widget, WidgetManager, WidgetOpenerOptions } from '@theia/core/lib/browser';
 import { CustomEditor, CustomEditorPriority, CustomEditorSelector } from '../../../common';
-import * as glob from './glob';
 import { CustomEditorWidget } from './custom-editor-widget';
 import { v4 } from 'uuid';
 import { Emitter } from '@theia/core';
+import { match } from '@theia/core/lib/common/glob';
 
 export class CustomEditorOpener implements OpenHandler {
 
@@ -96,7 +96,7 @@ export class CustomEditorOpener implements OpenHandler {
 
     selectorMatches(selector: CustomEditorSelector, resource: URI): boolean {
         if (selector.filenamePattern) {
-            if (glob.match(selector.filenamePattern.toLowerCase(), resource.path.name.toLowerCase() + resource.path.ext.toLowerCase())) {
+            if (match(selector.filenamePattern.toLowerCase(), resource.path.name.toLowerCase() + resource.path.ext.toLowerCase())) {
                 return true;
             }
         }

package/src/main/browser/debug/plugin-debug-service.ts

@@ -15,6 +15,8 @@
 // *****************************************************************************
 
 import { DebuggerDescription, DebugPath, DebugService } from '@theia/debug/lib/common/debug-service';
+import debounce = require('@theia/core/shared/lodash.debounce');
+import { Emitter, Event } from '@theia/core';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { DebugConfiguration } from '@theia/debug/lib/common/debug-configuration';
 import { IJSONSchema, IJSONSchemaSnippet } from '@theia/core/lib/common/json-schema';
@@ -40,6 +42,11 @@ export class PluginDebugService implements DebugService {
     protected readonly configurationProviders = new Map<number, PluginDebugConfigurationProvider>();
     protected readonly toDispose = new DisposableCollection();
 
+    protected readonly onDidChangeDebugConfigurationProvidersEmitter = new Emitter<void>();
+    get onDidChangeDebugConfigurationProviders(): Event<void> {
+        return this.onDidChangeDebugConfigurationProvidersEmitter.event;
+    }
+
     // maps session and contribution
     protected readonly sessionId2contrib = new Map<string, PluginDebugAdapterContribution>();
     protected delegated: DebugService;
@@ -79,14 +86,21 @@ export class PluginDebugService implements DebugService {
         this.contributors.delete(debugType);
     }
 
+    // debouncing to send a single notification for multiple registrations at initialization time
+    fireOnDidConfigurationProvidersChanged = debounce(() => {
+        this.onDidChangeDebugConfigurationProvidersEmitter.fire();
+    }, 100);
+
     registerDebugConfigurationProvider(provider: PluginDebugConfigurationProvider): Disposable {
         const handle = provider.handle;
         this.configurationProviders.set(handle, provider);
+        this.fireOnDidConfigurationProvidersChanged();
         return Disposable.create(() => this.unregisterDebugConfigurationProvider(handle));
     }
 
     unregisterDebugConfigurationProvider(handle: number): void {
         this.configurationProviders.delete(handle);
+        this.fireOnDidConfigurationProvidersChanged();
     }
 
     async debugTypes(): Promise<string[]> {
@@ -123,6 +137,24 @@ export class PluginDebugService implements DebugService {
         return results;
     }
 
+    async fetchDynamicDebugConfiguration(name: string, providerType: string): Promise<DebugConfiguration | undefined> {
+        const pluginProviders =
+            Array.from(this.configurationProviders.values()).filter(p => (
+                p.triggerKind === DebugConfigurationProviderTriggerKind.Dynamic &&
+                p.type === providerType &&
+                p.provideDebugConfigurations
+            ));
+
+        for (const provider of pluginProviders) {
+            const configurations = await provider.provideDebugConfigurations(undefined);
+            for (const configuration of configurations) {
+                if (configuration.name === name) {
+                    return configuration;
+                }
+            }
+        }
+    }
+
     async provideDynamicDebugConfigurations(): Promise<Record<string, DebugConfiguration[]>> {
         const pluginProviders =
             Array.from(this.configurationProviders.values()).filter(p => (
@@ -134,9 +166,6 @@ export class PluginDebugService implements DebugService {
 
         await Promise.all(pluginProviders.map(async provider => {
             const configurations = await provider.provideDebugConfigurations(undefined);
-            for (const configuration of configurations) {
-                configuration.dynamic = true;
-            }
             let configurationsPerType = configurationsRecord[provider.type];
             configurationsPerType = configurationsPerType ? configurationsPerType.concat(configurations) : configurations;
 

package/src/main/browser/debug/plugin-debug-session-factory.ts

@@ -30,8 +30,8 @@ import { TerminalOptionsExt } from '../../../common/plugin-api-rpc';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { DebugContribution } from '@theia/debug/lib/browser/debug-contribution';
 import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
-import { Channel } from '@theia/debug/lib/common/debug-service';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { PluginChannel } from '../../../common/connection';
 
 export class PluginDebugSession extends DebugSession {
     constructor(
@@ -71,7 +71,7 @@ export class PluginDebugSessionFactory extends DefaultDebugSessionFactory {
         protected override readonly messages: MessageClient,
         protected override readonly outputChannelManager: OutputChannelManager,
         protected override readonly debugPreferences: DebugPreferences,
-        protected readonly connectionFactory: (sessionId: string) => Promise<Channel>,
+        protected readonly connectionFactory: (sessionId: string) => Promise<PluginChannel>,
         protected override readonly fileService: FileService,
         protected readonly terminalOptionsExt: TerminalOptionsExt | undefined,
         protected override readonly debugContributionProvider: ContributionProvider<DebugContribution>,

package/src/main/browser/documents-main.ts

@@ -16,11 +16,10 @@
 import { DocumentsMain, MAIN_RPC_CONTEXT, DocumentsExt } from '../../common/plugin-api-rpc';
 import { UriComponents } from '../../common/uri-components';
 import { EditorsAndDocumentsMain } from './editors-and-documents-main';
-import { DisposableCollection, Disposable } from '@theia/core';
+import { DisposableCollection, Disposable, UntitledResourceResolver } from '@theia/core';
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { EditorModelService } from './text-editor-model-service';
-import { UntitledResourceResolver } from './editor/untitled-resource';
 import { EditorManager, EditorOpenerOptions } from '@theia/editor/lib/browser';
 import URI from '@theia/core/lib/common/uri';
 import { URI as CodeURI } from '@theia/core/shared/vscode-uri';
@@ -248,16 +247,35 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
         }
         /* fall back to side group -> split relative to the active widget */
         let widgetOptions: ApplicationShell.WidgetOptions | undefined = { mode: 'split-right' };
-        const viewColumn = options.viewColumn;
+        let viewColumn = options.viewColumn;
+        if (viewColumn === -2) {
+            /* show besides -> compute current column and adjust viewColumn accordingly */
+            const tabBars = shell.mainAreaTabBars;
+            const currentTabBar = shell.currentTabBar;
+            if (currentTabBar) {
+                const currentColumn = tabBars.indexOf(currentTabBar);
+                if (currentColumn > -1) {
+                    // +2 because conversion from 0-based to 1-based index and increase of 1
+                    viewColumn = currentColumn + 2;
+                }
+            }
+        }
         if (viewColumn === undefined || viewColumn === -1) {
             /* active group -> skip (default behaviour) */
             widgetOptions = undefined;
-        } else if (viewColumn > 0) {
+        } else if (viewColumn > 0 && shell.mainAreaTabBars.length > 0) {
             const tabBars = shell.mainAreaTabBars;
-            // convert to zero-based index
-            const tabBar = tabBars[viewColumn - 1];
-            if (tabBar && tabBar.currentTitle) {
-                widgetOptions = { ref: tabBar.currentTitle.owner };
+            if (viewColumn <= tabBars.length) {
+                // convert to zero-based index
+                const tabBar = tabBars[viewColumn - 1];
+                if (tabBar?.currentTitle) {
+                    widgetOptions = { ref: tabBar.currentTitle.owner };
+                }
+            } else {
+                const tabBar = tabBars[tabBars.length - 1];
+                if (tabBar?.currentTitle) {
+                    widgetOptions!.ref = tabBar.currentTitle.owner;
+                }
             }
         }
         return {

package/src/main/browser/editors-and-documents-main.ts

@@ -41,6 +41,7 @@ export class EditorsAndDocumentsMain implements Disposable {
     private readonly textEditors = new Map<string, TextEditorMain>();
 
     private readonly modelService: EditorModelService;
+    private readonly editorService: EditorManager;
 
     private readonly onTextEditorAddEmitter = new Emitter<TextEditorMain[]>();
     private readonly onTextEditorRemoveEmitter = new Emitter<string[]>();
@@ -59,10 +60,10 @@ export class EditorsAndDocumentsMain implements Disposable {
     constructor(rpc: RPCProtocol, container: interfaces.Container) {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT);
 
-        const editorService = container.get(EditorManager);
+        this.editorService = container.get(EditorManager);
         this.modelService = container.get(EditorModelService);
 
-        this.stateComputer = new EditorAndDocumentStateComputer(d => this.onDelta(d), editorService, this.modelService);
+        this.stateComputer = new EditorAndDocumentStateComputer(d => this.onDelta(d), this.editorService, this.modelService);
         this.toDispose.push(this.stateComputer);
         this.toDispose.push(this.onTextEditorAddEmitter);
         this.toDispose.push(this.onTextEditorRemoveEmitter);
@@ -168,6 +169,19 @@ export class EditorsAndDocumentsMain implements Disposable {
     saveAll(includeUntitled?: boolean): Promise<boolean> {
         return this.modelService.saveAll(includeUntitled);
     }
+
+    hideEditor(id: string): Promise<void> {
+        for (const editorWidget of this.editorService.all) {
+            const monacoEditor = MonacoEditor.get(editorWidget);
+            if (monacoEditor) {
+                if (id === new EditorSnapshot(monacoEditor).id) {
+                    editorWidget.close();
+                    break;
+                }
+            }
+        }
+        return Promise.resolve();
+    }
 }
 
 class EditorAndDocumentStateComputer implements Disposable {

package/src/main/browser/languages-main.ts

@@ -1075,7 +1075,8 @@ function reviveOnEnterRule(onEnterRule: SerializedOnEnterRule): monaco.languages
     return {
         beforeText: reviveRegExp(onEnterRule.beforeText)!,
         afterText: reviveRegExp(onEnterRule.afterText),
-        action: onEnterRule.action
+        previousLineText: reviveRegExp(onEnterRule.previousLineText),
+        action: onEnterRule.action,
     };
 }
 

package/src/main/browser/main-context.ts

@@ -46,7 +46,6 @@ import { OpenerService } from '@theia/core/lib/browser/opener-service';
 import { ApplicationShell } from '@theia/core/lib/browser/shell/application-shell';
 import { MonacoBulkEditService } from '@theia/monaco/lib/browser/monaco-bulk-edit-service';
 import { MonacoEditorService } from '@theia/monaco/lib/browser/monaco-editor-service';
-import { UntitledResourceResolver } from './editor/untitled-resource';
 import { MainFileSystemEventService } from './main-file-system-event-service';
 import { LabelServiceMainImpl } from './label-service-main';
 import { TimelineMainImpl } from './timeline-main';
@@ -58,6 +57,8 @@ import { SecretsMainImpl } from './secrets-main';
 import { WebviewViewsMainImpl } from './webview-views/webview-views-main';
 import { MonacoLanguages } from '@theia/monaco/lib/browser/monaco-languages';
 import { NotificationExtImpl } from '../../plugin/notification';
+import { UntitledResourceResolver } from '@theia/core/lib/common/resource';
+import { ThemeService } from '@theia/core/lib/browser/theming';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
     const authenticationMain = new AuthenticationMainImpl(rpc, container);
@@ -94,7 +95,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
     const bulkEditService = container.get(MonacoBulkEditService);
     const monacoEditorService = container.get(MonacoEditorService);
-    const editorsMain = new TextEditorsMainImpl(editorsAndDocuments, rpc, bulkEditService, monacoEditorService);
+    const editorsMain = new TextEditorsMainImpl(editorsAndDocuments, documentsMain, rpc, bulkEditService, monacoEditorService);
     rpc.set(PLUGIN_RPC_CONTEXT.TEXT_EDITORS_MAIN, editorsMain);
 
     // start listening only after all clients are subscribed to events
@@ -178,7 +179,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const timelineMain = new TimelineMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.TIMELINE_MAIN, timelineMain);
 
-    const themingMain = new ThemingMainImpl(rpc);
+    const themingMain = new ThemingMainImpl(rpc, container.get(ThemeService));
     rpc.set(PLUGIN_RPC_CONTEXT.THEMING_MAIN, themingMain);
 
     const commentsMain = new CommentsMainImp(rpc, container);

package/src/main/browser/plugin-contribution-handler.ts

@@ -20,7 +20,7 @@ import { TextmateRegistry, getEncodedLanguageId, MonacoTextmateService, GrammarD
 import { MenusContributionPointHandler } from './menus/menus-contribution-handler';
 import { PluginViewRegistry } from './view/plugin-view-registry';
 import { PluginCustomEditorRegistry } from './custom-editors/plugin-custom-editor-registry';
-import { PluginContribution, IndentationRules, FoldingRules, ScopeMap, DeployedPlugin, GrammarsContribution } from '../../common';
+import { PluginContribution, IndentationRules, FoldingRules, ScopeMap, DeployedPlugin, GrammarsContribution, EnterAction, OnEnterRule } from '../../common';
 import {
     DefaultUriLabelProviderContribution,
     LabelProviderContribution,
@@ -172,7 +172,8 @@ export class PluginContributionHandler {
                         comments: langConfiguration.comments,
                         folding: this.convertFolding(langConfiguration.folding),
                         surroundingPairs: langConfiguration.surroundingPairs,
-                        indentationRules: this.convertIndentationRules(langConfiguration.indentationRules)
+                        indentationRules: this.convertIndentationRules(langConfiguration.indentationRules),
+                        onEnterRules: this.convertOnEnterRules(langConfiguration.onEnterRules),
                     }));
                 }
             }
@@ -484,7 +485,6 @@ export class PluginContributionHandler {
         }
 
         return result;
-
     }
 
     private convertTokenTypes(tokenTypes?: ScopeMap): ITokenTypeMap | undefined {
@@ -530,4 +530,42 @@ export class PluginContributionHandler {
         return result;
     }
 
+    private convertOnEnterRules(onEnterRules?: OnEnterRule[]): monaco.languages.OnEnterRule[] | undefined {
+        if (!onEnterRules) {
+            return undefined;
+        }
+
+        const result: monaco.languages.OnEnterRule[] = [];
+        for (const onEnterRule of onEnterRules) {
+            const rule: monaco.languages.OnEnterRule = {
+                beforeText: this.createRegex(onEnterRule.beforeText)!,
+                afterText: this.createRegex(onEnterRule.afterText),
+                previousLineText: this.createRegex(onEnterRule.previousLineText),
+                action: this.createEnterAction(onEnterRule.action),
+            };
+            result.push(rule);
+        }
+
+        return result;
+    }
+
+    private createEnterAction(action: EnterAction): monaco.languages.EnterAction {
+        let indentAction: monaco.languages.IndentAction;
+        switch (action.indent) {
+            case 'indent':
+                indentAction = monaco.languages.IndentAction.Indent;
+                break;
+            case 'indentOutdent':
+                indentAction = monaco.languages.IndentAction.IndentOutdent;
+                break;
+            case 'outdent':
+                indentAction = monaco.languages.IndentAction.Outdent;
+                break;
+            default:
+                indentAction = monaco.languages.IndentAction.None;
+                break;
+        }
+        return { indentAction, appendText: action.appendText, removeText: action.removeText };
+    }
+
 }

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

@@ -30,7 +30,7 @@ import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposa
 import { Emitter } from '@theia/core/lib/common/event';
 import { RecursivePartial } from '@theia/core/lib/common/types';
 import { LabelProviderContribution, DidChangeLabelEvent, LabelProvider, URIIconReference } from '@theia/core/lib/browser/label-provider';
-import { ThemeType } from '@theia/core/lib/browser/theming';
+import { ThemeType } from '@theia/core/lib/common/theme';
 import { FileStatNode, DirNode } from '@theia/filesystem/lib/browser';
 import { WorkspaceRootNode } from '@theia/navigator/lib/browser/navigator-tree';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';