@theia/monaco 1.46.1 → 1.47.0

package/src/browser/monaco-editor-provider.ts

@@ -21,17 +21,11 @@ import { DiffUris } from '@theia/core/lib/browser/diff-uris';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { DisposableCollection, deepClone, Disposable } from '@theia/core/lib/common';
 import { TextDocumentSaveReason } from '@theia/core/shared/vscode-languageserver-protocol';
-import { MonacoCommandServiceFactory } from './monaco-command-service';
-import { MonacoContextMenuService } from './monaco-context-menu';
 import { MonacoDiffEditor } from './monaco-diff-editor';
 import { MonacoDiffNavigatorFactory } from './monaco-diff-navigator-factory';
 import { EditorServiceOverrides, MonacoEditor, MonacoEditorServices } from './monaco-editor';
 import { MonacoEditorModel, WillSaveMonacoModelEvent } from './monaco-editor-model';
-import { MonacoEditorService } from './monaco-editor-service';
-import { MonacoTextModelService } from './monaco-text-model-service';
 import { MonacoWorkspace } from './monaco-workspace';
-import { MonacoBulkEditService } from './monaco-bulk-edit-service';
-import { ApplicationServer } from '@theia/core/lib/common/application-protocol';
 import { ContributionProvider } from '@theia/core';
 import { KeybindingRegistry, OpenerService, open, WidgetOpenerOptions, FormatType } from '@theia/core/lib/browser';
 import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
@@ -39,23 +33,17 @@ import { HttpOpenHandlerOptions } from '@theia/core/lib/browser/http-open-handle
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
 import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
-import { MonacoQuickInputImplementation } from './monaco-quick-input-service';
-import { ContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
 import * as monaco from '@theia/monaco-editor-core';
-import { OpenerService as MonacoOpenerService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/openerService';
-import { StandaloneCommandService, StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { IOpenerService, OpenExternalOptions, OpenInternalOptions } from '@theia/monaco-editor-core/esm/vs/platform/opener/common/opener';
-import { SimpleKeybinding } from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
-import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
-import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding';
 import { timeoutReject } from '@theia/core/lib/common/promise-util';
-import { ITextModelService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
 import { IContextMenuService } from '@theia/monaco-editor-core/esm/vs/platform/contextview/browser/contextView';
-import { IBulkEditService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/bulkEditService';
+import { KeyCodeChord } from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
 import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
-import { IQuickInputService } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickInput';
-import { ICommandService } from '@theia/monaco-editor-core/esm/vs/platform/commands/common/commands';
+import { ITextModelService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
+import { IReference } from '@theia/monaco-editor-core/esm/vs/base/common/lifecycle';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 
 export const MonacoEditorFactory = Symbol('MonacoEditorFactory');
 export interface MonacoEditorFactory {
@@ -70,9 +58,6 @@ export class MonacoEditorProvider {
     @named(MonacoEditorFactory)
     protected readonly factories: ContributionProvider<MonacoEditorFactory>;
 
-    @inject(MonacoBulkEditService)
-    protected readonly bulkEditService: MonacoBulkEditService;
-
     @inject(MonacoEditorServices)
     protected readonly services: MonacoEditorServices;
 
@@ -85,9 +70,6 @@ export class MonacoEditorProvider {
     @inject(FileSystemPreferences)
     protected readonly filePreferences: FileSystemPreferences;
 
-    @inject(MonacoQuickInputImplementation)
-    protected readonly quickInputService: MonacoQuickInputImplementation;
-
     protected _current: MonacoEditor | undefined;
     /**
      * Returns the last focused MonacoEditor.
@@ -99,26 +81,16 @@ export class MonacoEditorProvider {
     }
 
     constructor(
-        @inject(MonacoEditorService) protected readonly codeEditorService: MonacoEditorService,
-        @inject(MonacoTextModelService) protected readonly textModelService: MonacoTextModelService,
-        @inject(MonacoContextMenuService) protected readonly contextMenuService: MonacoContextMenuService,
         @inject(MonacoToProtocolConverter) protected readonly m2p: MonacoToProtocolConverter,
         @inject(ProtocolToMonacoConverter) protected readonly p2m: ProtocolToMonacoConverter,
         @inject(MonacoWorkspace) protected readonly workspace: MonacoWorkspace,
-        @inject(MonacoCommandServiceFactory) protected readonly commandServiceFactory: MonacoCommandServiceFactory,
         @inject(EditorPreferences) protected readonly editorPreferences: EditorPreferences,
         @inject(MonacoDiffNavigatorFactory) protected readonly diffNavigatorFactory: MonacoDiffNavigatorFactory,
-        /** @deprecated since 1.6.0 */
-        @inject(ApplicationServer) protected readonly applicationServer: ApplicationServer,
-        @inject(ContextKeyService) protected readonly contextKeyService: ContextKeyService
     ) {
-        StandaloneServices.initialize({
-            [ICodeEditorService.toString()]: codeEditorService,
-        });
     }
 
     protected async getModel(uri: URI, toDispose: DisposableCollection): Promise<MonacoEditorModel> {
-        const reference = await this.textModelService.createModelReference(uri);
+        const reference = await StandaloneServices.get(ITextModelService).createModelReference(monaco.Uri.from(uri.toComponents())) as IReference<MonacoEditorModel>;
         // if document is invalid makes sure that all events from underlying resource are processed before throwing invalid model
         if (!reference.object.valid) {
             await reference.object.sync();
@@ -139,34 +111,20 @@ export class MonacoEditorProvider {
     protected async doCreateEditor(uri: URI, factory: (
         override: EditorServiceOverrides, toDispose: DisposableCollection) => Promise<MonacoEditor>
     ): Promise<MonacoEditor> {
-        const commandService = this.commandServiceFactory();
         const domNode = document.createElement('div');
-        const contextKeyService = this.contextKeyService.createScoped(domNode);
-        const { codeEditorService, textModelService, contextMenuService } = this;
-        const workspaceEditService = this.bulkEditService;
-        const toDispose = new DisposableCollection(commandService);
-        const openerService = new MonacoOpenerService(codeEditorService, commandService);
-        openerService.registerOpener({
+        const contextKeyService = StandaloneServices.get(IContextKeyService).createScoped(domNode);
+        StandaloneServices.get(IOpenerService).registerOpener({
             open: (u, options) => this.interceptOpen(u, options)
         });
         const overrides: EditorServiceOverrides = [
-            [ICodeEditorService, codeEditorService],
-            [ITextModelService, textModelService],
-            [IContextMenuService, contextMenuService],
-            [IBulkEditService, workspaceEditService],
             [IContextKeyService, contextKeyService],
-            [IOpenerService, openerService],
-            [IQuickInputService, this.quickInputService],
-            [ICommandService, commandService]
         ];
+        const toDispose = new DisposableCollection();
         const editor = await factory(overrides, toDispose);
         editor.onDispose(() => toDispose.dispose());
 
         this.injectKeybindingResolver(editor);
 
-        const standaloneCommandService = new StandaloneCommandService(StandaloneServices.get(IInstantiationService));
-        commandService.setDelegate(standaloneCommandService);
-
         toDispose.push(editor.onFocusChanged(focused => {
             if (focused) {
                 this._current = editor;
@@ -212,16 +170,16 @@ export class MonacoEditorProvider {
 
     protected injectKeybindingResolver(editor: MonacoEditor): void {
         const keybindingService = StandaloneServices.get(IKeybindingService);
-        keybindingService.resolveKeybinding = keybinding => [new MonacoResolvedKeybinding(MonacoResolvedKeybinding.keySequence(keybinding), this.keybindingRegistry)];
+        keybindingService.resolveKeybinding = keybinding => [new MonacoResolvedKeybinding(MonacoResolvedKeybinding.keySequence(keybinding.chords), this.keybindingRegistry)];
         keybindingService.resolveKeyboardEvent = keyboardEvent => {
-            const keybinding = new SimpleKeybinding(
+            const keybinding = new KeyCodeChord(
                 keyboardEvent.ctrlKey,
                 keyboardEvent.shiftKey,
                 keyboardEvent.altKey,
                 keyboardEvent.metaKey,
                 keyboardEvent.keyCode
-            ).toChord();
-            return new MonacoResolvedKeybinding(MonacoResolvedKeybinding.keySequence(keybinding), this.keybindingRegistry);
+            );
+            return new MonacoResolvedKeybinding(MonacoResolvedKeybinding.keySequence([keybinding]), this.keybindingRegistry);
         };
     }
 
@@ -248,13 +206,20 @@ export class MonacoEditorProvider {
             }
         }));
         toDispose.push(editor.onLanguageChanged(() => this.updateMonacoEditorOptions(editor)));
+        toDispose.push(editor.onDidChangeReadOnly(() => this.updateReadOnlyMessage(options, model.readOnly)));
         editor.document.onWillSaveModel(event => event.waitUntil(this.formatOnSave(editor, event)));
         return editor;
     }
+
+    protected updateReadOnlyMessage(options: MonacoEditor.IOptions, readOnly: boolean | MarkdownString ): void {
+        options.readOnlyMessage = MarkdownString.is(readOnly) ? readOnly : undefined;
+    }
+
     protected createMonacoEditorOptions(model: MonacoEditorModel): MonacoEditor.IOptions {
         const options = this.createOptions(this.preferencePrefixes, model.uri, model.languageId);
         options.model = model.textEditorModel;
         options.readOnly = model.readOnly;
+        this.updateReadOnlyMessage(options, model.readOnly);
         options.lineNumbersMinChars = model.lineNumbersMinChars;
         return options;
     }
@@ -336,6 +301,7 @@ export class MonacoEditorProvider {
         const options = this.createOptions(this.diffPreferencePrefixes, modified.uri, modified.languageId);
         options.originalEditable = !original.readOnly;
         options.readOnly = modified.readOnly;
+        options.readOnlyMessage = MarkdownString.is(modified.readOnly) ? modified.readOnly : undefined;
         return options;
     }
     protected updateMonacoDiffEditorOptions(editor: MonacoDiffEditor, event?: EditorPreferenceChange, resourceUri?: string): void {
@@ -403,10 +369,10 @@ export class MonacoEditorProvider {
             const overrides = override ? Array.from(override) : [];
             overrides.push([IContextMenuService, { showContextMenu: () => {/** no op! */ } }]);
             const document = new MonacoEditorModel({
-                    uri,
-                    readContents: async () => '',
-                    dispose: () => { }
-                }, this.m2p, this.p2m);
+                uri,
+                readContents: async () => '',
+                dispose: () => { }
+            }, this.m2p, this.p2m);
             toDispose.push(document);
             const model = (await document.load()).textEditorModel;
             return new MonacoEditor(

package/src/browser/monaco-editor-service.ts

@@ -22,15 +22,20 @@ import { MonacoEditor } from './monaco-editor';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { MonacoEditorModel } from './monaco-editor-model';
 import { IResourceEditorInput, ITextResourceEditorInput } from '@theia/monaco-editor-core/esm/vs/platform/editor/common/editor';
-import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
-import { IStandaloneThemeService } from '@theia/monaco-editor-core/esm/vs/editor/standalone/common/standaloneTheme';
 import { StandaloneCodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditorService';
 import { StandaloneCodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
 import { ICodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
-import { ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
+import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 
 decorate(injectable(), StandaloneCodeEditorService);
 
+export const VSCodeContextKeyService = Symbol('VSCodeContextKeyService');
+export const VSCodeThemeService = Symbol('VSCodeThemeService');
+
+export const MonacoEditorServiceFactory = Symbol('MonacoEditorServiceFactory');
+export type MonacoEditorServiceFactoryType = (contextKeyService: IContextKeyService, themeService: IThemeService) => MonacoEditorService;
+
 @injectable()
 export class MonacoEditorService extends StandaloneCodeEditorService {
 
@@ -51,8 +56,8 @@ export class MonacoEditorService extends StandaloneCodeEditorService {
     @inject(PreferenceService)
     protected readonly preferencesService: PreferenceService;
 
-    constructor(@inject(VSCodeContextKeyService) contextKeyService: VSCodeContextKeyService) {
-        super(contextKeyService, StandaloneServices.get(IStandaloneThemeService));
+    constructor(@inject(VSCodeContextKeyService) contextKeyService: IContextKeyService, @inject(VSCodeThemeService) themeService: IThemeService) {
+        super(contextKeyService, themeService);
     }
 
     /**

package/src/browser/monaco-editor.ts

@@ -35,7 +35,8 @@ import {
     EditorDecoration,
     EditorMouseEvent,
     EncodingMode,
-    EditorDecorationOptions
+    EditorDecorationOptions,
+    MouseTargetType
 } from '@theia/editor/lib/browser';
 import { MonacoEditorModel } from './monaco-editor-model';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
@@ -46,9 +47,10 @@ import * as monaco from '@theia/monaco-editor-core';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { ILanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/languages/language';
 import { IInstantiationService, ServiceIdentifier } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
-import { ICodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
-import { ServiceCollection } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/serviceCollection';
+import { ICodeEditor, IMouseTargetMargin } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
 import { IStandaloneEditorConstructionOptions, StandaloneEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
+import { ServiceCollection } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/serviceCollection';
+import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 
 export type ServicePair<T> = [ServiceIdentifier<T>, T];
 
@@ -85,6 +87,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     protected readonly onFocusChangedEmitter = new Emitter<boolean>();
     protected readonly onDocumentContentChangedEmitter = new Emitter<TextDocumentChangeEvent>();
     protected readonly onMouseDownEmitter = new Emitter<EditorMouseEvent>();
+    readonly onDidChangeReadOnly = this.document.onDidChangeReadOnly;
     protected readonly onLanguageChangedEmitter = new Emitter<string>();
     readonly onLanguageChanged = this.onLanguageChangedEmitter.event;
     protected readonly onScrollChangedEmitter = new Emitter<void>();
@@ -116,7 +119,10 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         this.autoSizing = options && options.autoSizing !== undefined ? options.autoSizing : false;
         this.minHeight = options && options.minHeight !== undefined ? options.minHeight : -1;
         this.maxHeight = options && options.maxHeight !== undefined ? options.maxHeight : -1;
-        this.toDispose.push(this.create(options, override));
+        this.toDispose.push(this.create({
+            ...MonacoEditor.createReadOnlyOptions(document.readOnly),
+            ...options
+        }, override));
         this.addHandlers(this.editor);
     }
 
@@ -151,7 +157,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     }
 
     protected getInstantiatorWithOverrides(override?: EditorServiceOverrides): IInstantiationService {
-        const instantiator = StandaloneServices.initialize({});
+        const instantiator = StandaloneServices.get(IInstantiationService);
         if (override) {
             const overrideServices = new ServiceCollection(...override);
             return instantiator.createChild(overrideServices);
@@ -185,12 +191,12 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
             const { element, position, range } = e.target;
             this.onMouseDownEmitter.fire({
                 target: {
-                    ...e.target,
+                    type: e.target.type as unknown as MouseTargetType,
                     element: element || undefined,
                     mouseColumn: this.m2p.asPosition(undefined, e.target.mouseColumn).character,
                     range: range && this.m2p.asRange(range) || undefined,
                     position: position && this.m2p.asPosition(position.lineNumber, position.column) || undefined,
-                    detail: (e.target as monaco.editor.IMouseTargetMargin).detail || {},
+                    detail: (e.target as unknown as IMouseTargetMargin).detail || {},
                 },
                 event: e.event.browserEvent
             });
@@ -198,6 +204,9 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         this.toDispose.push(codeEditor.onDidScrollChange(e => {
             this.onScrollChangedEmitter.fire(undefined);
         }));
+        this.toDispose.push(this.onDidChangeReadOnly(readOnly => {
+            codeEditor.updateOptions(MonacoEditor.createReadOnlyOptions(readOnly));
+        }));
     }
 
     getVisibleRanges(): Range[] {
@@ -220,8 +229,8 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         return this.onDocumentContentChangedEmitter.event;
     }
 
-    get isReadonly(): boolean {
-        return this.document.isReadonly();
+    get isReadonly(): boolean | MarkdownString {
+        return this.document.readOnly;
     }
 
     get cursor(): Position {
@@ -641,4 +650,14 @@ export namespace MonacoEditor {
             return candidate && candidate.getControl() === control;
         });
     }
+
+    export function createReadOnlyOptions(readOnly?: boolean | MarkdownString): monaco.editor.IEditorOptions {
+        if (typeof readOnly === 'boolean') {
+            return { readOnly, readOnlyMessage: undefined };
+        }
+        if (readOnly) {
+            return { readOnly: true, readOnlyMessage: readOnly };
+        }
+        return {};
+    }
 }

package/src/browser/monaco-frontend-application-contribution.ts

@@ -20,15 +20,7 @@ import { MonacoSnippetSuggestProvider } from './monaco-snippet-suggest-provider'
 import * as monaco from '@theia/monaco-editor-core';
 import { setSnippetSuggestSupport } from '@theia/monaco-editor-core/esm/vs/editor/contrib/suggest/browser/suggest';
 import { CompletionItemProvider } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
-import { MonacoEditorService } from './monaco-editor-service';
 import { MonacoTextModelService } from './monaco-text-model-service';
-import { ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
-import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
-import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
-import { ITextModelService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
-import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
-import { IContextMenuService } from '@theia/monaco-editor-core/esm/vs/platform/contextview/browser/contextView';
-import { MonacoContextMenuService } from './monaco-context-menu';
 import { MonacoThemingService } from './monaco-theming-service';
 import { isHighContrast } from '@theia/core/lib/common/theme';
 import { editorOptionsRegistry, IEditorOption } from '@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
@@ -36,28 +28,12 @@ import { MAX_SAFE_INTEGER } from '@theia/core';
 import { editorGeneratedPreferenceProperties } from '@theia/editor/lib/browser/editor-generated-preference-schema';
 import { WorkspaceFileService } from '@theia/workspace/lib/common/workspace-file-service';
 
-let theiaDidInitialize = false;
-const originalInitialize = StandaloneServices.initialize;
-StandaloneServices.initialize = overrides => {
-    if (!theiaDidInitialize) {
-        console.warn('Monaco was initialized before overrides were installed by Theia\'s initialization.'
-            + ' Please check the lifecycle of services that use Monaco and ensure that Monaco entities are not instantiated before Theia is initialized.', new Error());
-    }
-    return originalInitialize(overrides);
-};
-
 @injectable()
 export class MonacoFrontendApplicationContribution implements FrontendApplicationContribution, StylingParticipant {
 
-    @inject(MonacoEditorService)
-    protected readonly codeEditorService: MonacoEditorService;
-
     @inject(MonacoTextModelService)
     protected readonly textModelService: MonacoTextModelService;
 
-    @inject(VSCodeContextKeyService)
-    protected readonly contextKeyService: VSCodeContextKeyService;
-
     @inject(MonacoSnippetSuggestProvider)
     protected readonly snippetSuggestProvider: MonacoSnippetSuggestProvider;
 
@@ -67,9 +43,6 @@ export class MonacoFrontendApplicationContribution implements FrontendApplicatio
     @inject(QuickAccessRegistry)
     protected readonly quickAccessRegistry: QuickAccessRegistry;
 
-    @inject(MonacoContextMenuService)
-    protected readonly contextMenuService: MonacoContextMenuService;
-
     @inject(MonacoThemingService) protected readonly monacoThemingService: MonacoThemingService;
 
     @inject(WorkspaceFileService) protected readonly workspaceFileService: WorkspaceFileService;
@@ -77,14 +50,6 @@ export class MonacoFrontendApplicationContribution implements FrontendApplicatio
     @postConstruct()
     protected init(): void {
         this.addAdditionalPreferenceValidations();
-        const { codeEditorService, textModelService, contextKeyService, contextMenuService } = this;
-        theiaDidInitialize = true;
-        StandaloneServices.initialize({
-            [ICodeEditorService.toString()]: codeEditorService,
-            [ITextModelService.toString()]: textModelService,
-            [IContextKeyService.toString()]: contextKeyService,
-            [IContextMenuService.toString()]: contextMenuService,
-        });
         // Monaco registers certain quick access providers (e.g. QuickCommandAccess) at import time, but we want to use our own.
         this.quickAccessRegistry.clear();
 

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

@@ -31,7 +31,7 @@ Object.assign(MonacoNls, {
 });
 
 import '../../src/browser/style/index.css';
-import { ContainerModule, decorate, injectable, interfaces } from '@theia/core/shared/inversify';
+import { ContainerModule, interfaces } from '@theia/core/shared/inversify';
 import { MenuContribution, CommandContribution, quickInputServicePath } from '@theia/core/lib/common';
 import {
     FrontendApplicationContribution, KeybindingContribution,
@@ -45,12 +45,12 @@ import { MonacoEditorCommandHandlers } from './monaco-command';
 import { MonacoKeybindingContribution } from './monaco-keybinding';
 import { MonacoLanguages } from './monaco-languages';
 import { MonacoWorkspace } from './monaco-workspace';
-import { MonacoEditorService } from './monaco-editor-service';
+import { MonacoEditorService, MonacoEditorServiceFactory, VSCodeContextKeyService, VSCodeThemeService } from './monaco-editor-service';
 import { MonacoTextModelService, MonacoEditorModelFactory } from './monaco-text-model-service';
 import { MonacoContextMenuService } from './monaco-context-menu';
 import { MonacoOutlineContribution } from './monaco-outline-contribution';
 import { MonacoStatusBarContribution } from './monaco-status-bar-contribution';
-import { MonacoCommandService, MonacoCommandServiceFactory } from './monaco-command-service';
+import { MonacoCommandService } from './monaco-command-service';
 import { MonacoCommandRegistry } from './monaco-command-registry';
 import { MonacoDiffNavigatorFactory } from './monaco-diff-navigator-factory';
 import { MonacoFrontendApplicationContribution } from './monaco-frontend-application-contribution';
@@ -80,16 +80,15 @@ import { GotoLineQuickAccessContribution } from './monaco-gotoline-quick-access'
 import { GotoSymbolQuickAccessContribution } from './monaco-gotosymbol-quick-access';
 import { QuickAccessContribution, QuickAccessRegistry } from '@theia/core/lib/browser/quick-input/quick-access';
 import { MonacoQuickAccessRegistry } from './monaco-quick-access-registry';
-import { ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
 import { ConfigurationTarget, IConfigurationChangeEvent, IConfigurationService } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configuration';
-import { StandaloneConfigurationService, StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { StandaloneConfigurationService } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { Configuration } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configurationModels';
 import { MarkdownRenderer } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
 import { MonacoMarkdownRenderer } from './markdown-renderer/monaco-markdown-renderer';
 import { ThemeService } from '@theia/core/lib/browser/theming';
 import { ThemeServiceWithDB } from './monaco-indexed-db';
-
-decorate(injectable(), VSCodeContextKeyService);
+import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoThemingService).toSelf().inSingletonScope();
@@ -114,15 +113,16 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 
     bind(MonacoWorkspace).toSelf().inSingletonScope();
 
-    bind(MonacoConfigurationService).toDynamicValue(({ container }) =>
-        createMonacoConfigurationService(container)
-    ).inSingletonScope();
-    bind(VSCodeContextKeyService).toDynamicValue(({ container }) =>
-        new VSCodeContextKeyService(container.get(MonacoConfigurationService))
-    ).inSingletonScope();
+    bind(MonacoConfigurationService).toDynamicValue(({ container }) => createMonacoConfigurationService(container)).inSingletonScope();
 
     bind(MonacoBulkEditService).toSelf().inSingletonScope();
-    bind(MonacoEditorService).toSelf().inSingletonScope();
+    bind(MonacoEditorServiceFactory).toFactory((context: interfaces.Context) => (contextKeyService: IContextKeyService, themeService: IThemeService) => {
+        const child = context.container.createChild();
+        child.bind(VSCodeContextKeyService).toConstantValue(contextKeyService);
+        child.bind(VSCodeThemeService).toConstantValue(themeService);
+        child.bind(MonacoEditorService).toSelf().inSingletonScope();
+        return child.get(MonacoEditorService);
+    });
     bind(MonacoTextModelService).toSelf().inSingletonScope();
     bind(MonacoContextMenuService).toSelf().inSingletonScope();
     bind(MonacoEditorServices).toSelf().inSingletonScope();
@@ -130,7 +130,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bindContributionProvider(bind, MonacoEditorFactory);
     bindContributionProvider(bind, MonacoEditorModelFactory);
     bind(MonacoCommandService).toSelf().inTransientScope();
-    bind(MonacoCommandServiceFactory).toAutoFactory(MonacoCommandService);
 
     bind(TextEditorProvider).toProvider(context =>
         uri => context.container.get(MonacoEditorProvider).get(uri)
@@ -198,7 +197,7 @@ export const MonacoConfigurationService = Symbol('MonacoConfigurationService');
 export function createMonacoConfigurationService(container: interfaces.Container): IConfigurationService {
     const preferences = container.get<PreferenceService>(PreferenceService);
     const preferenceSchemaProvider = container.get<PreferenceSchemaProvider>(PreferenceSchemaProvider);
-    const service = StandaloneServices.get(IConfigurationService) as StandaloneConfigurationService;
+    const service = new StandaloneConfigurationService();
     const _configuration: Configuration = service['_configuration'];
 
     _configuration.getValue = (section, overrides) => {
@@ -216,6 +215,14 @@ export function createMonacoConfigurationService(container: interfaces.Container
         return proxy;
     };
 
+    /*
+     * Since we never read values from the underlying service, writing to it doesn't make sense. The standalone editor writes to the configuration when being created,
+     * which makes sense in the standalone case where there is no preference infrastructure in place. Those writes degrade the performance, however, so we patch the
+     * service to an empty implementation.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    service.updateValues = (values: [string, any][]) => Promise.resolve();
+
     const toTarget = (scope: PreferenceScope): ConfigurationTarget => {
         switch (scope) {
             case PreferenceScope.Default: return ConfigurationTarget.DEFAULT;
@@ -246,11 +253,12 @@ export function createMonacoConfigurationService(container: interfaces.Container
             overrides.push([override, [...values]]);
         }
         service['_onDidChangeConfiguration'].fire(<IConfigurationChangeEvent>{
+            sourceConfig: {},
             change: {
                 keys: [...context.keys],
                 overrides
             },
-            affectedKeys: [...context.affectedKeys],
+            affectedKeys: context.affectedKeys,
             source,
             affectsConfiguration: (prefix, options) => {
                 if (!context.affectedKeys.has(prefix)) {

package/src/browser/monaco-icon-registry.ts

@@ -15,9 +15,9 @@
 // *****************************************************************************
 
 import { injectable } from '@theia/core/shared/inversify';
-import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
 import { IconRegistry } from '@theia/core/lib/browser/icon-registry';
-import { IconDefinition, IconFontDefinition, getIconRegistry } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/iconRegistry';
+import { getIconRegistry } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/iconRegistry';
+import { IconDefinition, IconFontDefinition, ThemeIcon } from '@theia/core/lib/common/theme';
 
 @injectable()
 export class MonacoIconRegistry implements IconRegistry {
@@ -33,7 +33,8 @@ export class MonacoIconRegistry implements IconRegistry {
     }
 
     registerIconFont(id: string, definition: IconFontDefinition): IconFontDefinition {
-        return this.iconRegistry.registerIconFont(id, definition);
+        // need to cast because of vscode issue https://github.com/microsoft/vscode/issues/190584
+        return this.iconRegistry.registerIconFont(id, definition) as IconFontDefinition;
     }
 
     deregisterIconFont(id: string): void {
@@ -41,7 +42,8 @@ export class MonacoIconRegistry implements IconRegistry {
     }
 
     getIconFont(id: string): IconFontDefinition | undefined {
-        return this.iconRegistry.getIconFont(id);
+        // need to cast because of vscode issue https://github.com/microsoft/vscode/issues/190584
+        return this.iconRegistry.getIconFont(id) as IconFontDefinition;
     }
 }