@theia/monaco 1.24.0-next.46 → 1.24.0-next.49

package/src/browser/monaco-editor.ts

@@ -18,7 +18,7 @@ import { injectable, inject, unmanaged } from '@theia/core/shared/inversify';
 import { ElementExt } from '@theia/core/shared/@phosphor/domutils';
 import URI from '@theia/core/lib/common/uri';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
-import { DisposableCollection, Disposable, Emitter, Event } from '@theia/core/lib/common';
+import { DisposableCollection, Disposable, Emitter, Event, nullToUndefined, MaybeNull } from '@theia/core/lib/common';
 import {
     Dimension,
     EditorManager,
@@ -34,20 +34,25 @@ import {
     ReplaceTextParams,
     EditorDecoration,
     EditorMouseEvent,
-    EncodingMode
+    EncodingMode,
+    EditorDecorationOptions
 } from '@theia/editor/lib/browser';
 import { MonacoEditorModel } from './monaco-editor-model';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
 import { TextEdit } from '@theia/core/shared/vscode-languageserver-protocol';
 import { UTF8 } from '@theia/core/lib/common/encodings';
+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 { IStandaloneEditorConstructionOptions, StandaloneEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
 
-import IStandaloneEditorConstructionOptions = monaco.editor.IStandaloneEditorConstructionOptions;
-import IModelDeltaDecoration = monaco.editor.IModelDeltaDecoration;
-import IEditorOverrideServices = monaco.editor.IEditorOverrideServices;
-import IStandaloneCodeEditor = monaco.editor.IStandaloneCodeEditor;
-import IIdentifiedSingleEditOperation = monaco.editor.IIdentifiedSingleEditOperation;
-import IBoxSizing = ElementExt.IBoxSizing;
+export type ServicePair<T> = [ServiceIdentifier<T>, T];
+
+export interface EditorServiceOverrides extends Iterable<ServicePair<unknown>> { }
 
 @injectable()
 export class MonacoEditorServices {
@@ -73,7 +78,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     protected readonly autoSizing: boolean;
     protected readonly minHeight: number;
     protected readonly maxHeight: number;
-    protected editor: IStandaloneCodeEditor;
+    protected editor: monaco.editor.IStandaloneCodeEditor;
 
     protected readonly onCursorPositionChangedEmitter = new Emitter<Position>();
     protected readonly onSelectionChangedEmitter = new Emitter<Range>();
@@ -84,7 +89,6 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     readonly onLanguageChanged = this.onLanguageChangedEmitter.event;
     protected readonly onScrollChangedEmitter = new Emitter<void>();
     readonly onEncodingChanged = this.document.onDidChangeEncoding;
-    // eslint-disable-next-line no-null/no-null
     protected readonly onResizeEmitter = new Emitter<Dimension | null>();
     readonly onDidResize = this.onResizeEmitter.event;
 
@@ -96,7 +100,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         readonly node: HTMLElement,
         services: MonacoEditorServices,
         options?: MonacoEditor.IOptions,
-        override?: IEditorOverrideServices
+        override?: EditorServiceOverrides
     ) {
         super(services);
         this.toDispose.pushAll([
@@ -124,8 +128,8 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         return this.document.setEncoding(encoding, mode);
     }
 
-    protected create(options?: IStandaloneEditorConstructionOptions, override?: monaco.editor.IEditorOverrideServices): Disposable {
-        return this.editor = monaco.editor.create(this.node, {
+    protected create(options?: monaco.editor.IStandaloneEditorConstructionOptions | IStandaloneEditorConstructionOptions, override?: EditorServiceOverrides): Disposable {
+        const combinedOptions = {
             ...options,
             lightbulb: { enabled: true },
             fixedOverflowWidgets: true,
@@ -136,10 +140,22 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
                 verticalScrollbarSize: 10,
                 horizontalScrollbarSize: 10
             }
-        }, override);
+        } as IStandaloneEditorConstructionOptions;
+        const instantiator = this.getInstantiatorWithOverrides(override);
+        // Incomparability of internal and external interfaces.
+        return this.editor = instantiator.createInstance(StandaloneEditor, this.node, combinedOptions) as unknown as monaco.editor.IStandaloneCodeEditor;
+    }
+
+    protected getInstantiatorWithOverrides(override?: EditorServiceOverrides): IInstantiationService {
+        const instantiator = StandaloneServices.initialize({});
+        if (override) {
+            const overrideServices = new ServiceCollection(...override);
+            return instantiator.createChild(overrideServices);
+        }
+        return instantiator;
     }
 
-    protected addHandlers(codeEditor: IStandaloneCodeEditor): void {
+    protected addHandlers(codeEditor: monaco.editor.IStandaloneCodeEditor): void {
         this.toDispose.push(codeEditor.onDidChangeModelLanguage(e =>
             this.fireLanguageChanged(e.newLanguage)
         ));
@@ -169,7 +185,8 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
                     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
+                    position: position && this.m2p.asPosition(position.lineNumber, position.column) || undefined,
+                    detail: undefined,
                 },
                 event: e.event.browserEvent
             });
@@ -333,7 +350,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         this.editor.trigger(source, handlerId, payload);
     }
 
-    getControl(): IStandaloneCodeEditor {
+    getControl(): monaco.editor.IStandaloneCodeEditor {
         return this.editor;
     }
 
@@ -383,11 +400,11 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         return { width, height };
     }
 
-    protected getWidth(hostNode: HTMLElement, boxSizing: IBoxSizing): number {
+    protected getWidth(hostNode: HTMLElement, boxSizing: ElementExt.IBoxSizing): number {
         return hostNode.offsetWidth - boxSizing.horizontalSum;
     }
 
-    protected getHeight(hostNode: HTMLElement, boxSizing: IBoxSizing): number {
+    protected getHeight(hostNode: HTMLElement, boxSizing: ElementExt.IBoxSizing): number {
         if (!this.autoSizing) {
             return hostNode.offsetHeight - boxSizing.verticalSum;
         }
@@ -424,27 +441,46 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         }
     }
 
-    get commandService(): monaco.commands.ICommandService {
-        return this.editor._commandService;
-    }
-
-    get instantiationService(): monaco.instantiation.IInstantiationService {
-        return this.editor._instantiationService;
-    }
-
     deltaDecorations(params: DeltaDecorationParams): string[] {
         const oldDecorations = params.oldDecorations;
         const newDecorations = this.toDeltaDecorations(params);
         return this.editor.deltaDecorations(oldDecorations, newDecorations);
     }
 
-    protected toDeltaDecorations(params: DeltaDecorationParams): IModelDeltaDecoration[] {
-        return params.newDecorations.map(decoration => <IModelDeltaDecoration>{
-            ...decoration,
-            range: this.p2m.asRange(decoration.range),
+    protected toDeltaDecorations(params: DeltaDecorationParams): monaco.editor.IModelDeltaDecoration[] {
+        return params.newDecorations.map(({ options: theiaOptions, range }) => {
+            const options: monaco.editor.IModelDecorationOptions = {
+                ...theiaOptions,
+                hoverMessage: this.fromStringToMarkdownString(theiaOptions.hoverMessage),
+                glyphMarginHoverMessage: this.fromStringToMarkdownString(theiaOptions.glyphMarginHoverMessage)
+            };
+            return {
+                options,
+                range: this.p2m.asRange(range),
+            };
         });
     }
 
+    protected fromStringToMarkdownString(hoverMessage?: string | monaco.IMarkdownString | monaco.IMarkdownString[]): monaco.IMarkdownString | monaco.IMarkdownString[] | undefined {
+        if (typeof hoverMessage === 'string') {
+            return { value: hoverMessage };
+        }
+        return hoverMessage;
+    }
+
+    protected fromMarkdownToString(maybeMarkdown?: null | string | monaco.IMarkdownString | monaco.IMarkdownString[]): string | undefined {
+        if (!maybeMarkdown) {
+            return undefined;
+        }
+        if (typeof maybeMarkdown === 'string') {
+            return maybeMarkdown;
+        }
+        if (Array.isArray(maybeMarkdown)) {
+            return maybeMarkdown.map(({ value }) => value).join('\n');
+        }
+        return maybeMarkdown.value;
+    }
+
     getLinesDecorations(startLineNumber: number, endLineNumber: number): (EditorDecoration & Readonly<{ id: string }>)[] {
         const toPosition = (line: number): monaco.Position => this.p2m.asPosition({ line, character: 0 });
         const start = toPosition(startLineNumber).lineNumber;
@@ -457,12 +493,17 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
 
     protected toEditorDecoration(decoration: monaco.editor.IModelDecoration): EditorDecoration & Readonly<{ id: string }> {
         const range = this.m2p.asRange(decoration.range);
-        const { id, options } = decoration;
+        const { id, options: monacoOptions } = decoration;
+        const options: MaybeNull<EditorDecorationOptions> = {
+            ...monacoOptions,
+            hoverMessage: this.fromMarkdownToString(monacoOptions.hoverMessage),
+            glyphMarginHoverMessage: this.fromMarkdownToString(monacoOptions.hoverMessage),
+        };
         return {
-            options,
+            options: nullToUndefined(options),
             range,
             id
-        } as EditorDecoration & Readonly<{ id: string }>;
+        };
     }
 
     getVisibleColumn(position: Position): number {
@@ -470,7 +511,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     }
 
     async replaceText(params: ReplaceTextParams): Promise<boolean> {
-        const edits: IIdentifiedSingleEditOperation[] = params.replaceOperations.map(param => {
+        const edits: monaco.editor.IIdentifiedSingleEditOperation[] = params.replaceOperations.map(param => {
             const range = monaco.Range.fromPositions(this.p2m.asPosition(param.range.start), this.p2m.asPosition(param.range.end));
             return {
                 forceMoveMarkers: true,
@@ -486,7 +527,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     }
 
     executeEdits(edits: TextEdit[]): boolean {
-        return this.editor.executeEdits('MonacoEditor', this.p2m.asTextEdits(edits) as IIdentifiedSingleEditOperation[]);
+        return this.editor.executeEdits('MonacoEditor', this.p2m.asTextEdits(edits) as monaco.editor.IIdentifiedSingleEditOperation[]);
     }
 
     storeViewState(): object {
@@ -505,11 +546,11 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     }
 
     async detectLanguage(): Promise<void> {
-        const modeService = monaco.services.StaticServices.modeService.get();
+        const languageService = StandaloneServices.get(ILanguageService);
         const firstLine = this.document.textEditorModel.getLineContent(1);
         const model = this.getControl().getModel();
-        const language = modeService.createByFilepathOrFirstLine(model && model.uri, firstLine);
-        this.setLanguage(language.languageIdentifier.language);
+        const language = languageService.createByFilepathOrFirstLine(model && model.uri, firstLine);
+        this.setLanguage(language.languageId);
         this._languageAutoDetected = true;
     }
 
@@ -558,7 +599,7 @@ export namespace MonacoEditor {
         maxHeight?: number;
     }
 
-    export interface IOptions extends ICommonOptions, IStandaloneEditorConstructionOptions { }
+    export interface IOptions extends ICommonOptions, monaco.editor.IStandaloneEditorConstructionOptions { }
 
     export function getAll(manager: EditorManager): MonacoEditor[] {
         return manager.all.map(e => get(e)).filter(e => !!e) as MonacoEditor[];
@@ -580,16 +621,16 @@ export namespace MonacoEditor {
     }
 
     export function findByDocument(manager: EditorManager, document: MonacoEditorModel): MonacoEditor[] {
-        return getAll(manager).filter(editor => editor.documents.has(document));
+        return getAll(manager).filter(candidate => candidate.documents.has(document));
     }
 
-    export function getWidgetFor(manager: EditorManager, control: monaco.editor.ICodeEditor | undefined): EditorWidget | undefined {
+    export function getWidgetFor(manager: EditorManager, control: monaco.editor.ICodeEditor | ICodeEditor | undefined | null): EditorWidget | undefined {
         if (!control) {
             return undefined;
         }
         return manager.all.find(widget => {
-            const editor = get(widget);
-            return !!editor && editor.getControl() === control;
+            const candidate = get(widget);
+            return candidate && candidate.getControl() === control;
         });
     }
 }

package/src/browser/monaco-formatting-conflicts.ts

@@ -18,8 +18,12 @@ import { injectable, inject } from '@theia/core/shared/inversify';
 import { PreferenceService, FrontendApplicationContribution, PreferenceLanguageOverrideService } from '@theia/core/lib/browser';
 import { EditorManager } from '@theia/editor/lib/browser';
 import { MonacoQuickInputService } from './monaco-quick-input-service';
+import * as monaco from '@theia/monaco-editor-core';
+import { FormattingConflicts, FormattingMode } from '@theia/monaco-editor-core/esm/vs/editor/contrib/format/browser/format';
+import { DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
+import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
 
-type FormattingEditProvider = monaco.languages.DocumentFormattingEditProvider | monaco.languages.DocumentRangeFormattingEditProvider;
+type FormattingEditProvider = DocumentFormattingEditProvider | DocumentRangeFormattingEditProvider;
 
 const PREFERENCE_NAME = 'editor.defaultFormatter';
 
@@ -39,12 +43,13 @@ export class MonacoFormattingConflictsContribution implements FrontendApplicatio
     protected readonly editorManager: EditorManager;
 
     async initialize(): Promise<void> {
-        monaco.format.FormattingConflicts.setFormatterSelector(<T extends FormattingEditProvider>(
-            formatters: T[], document: monaco.editor.ITextModel, mode: monaco.format.FormattingMode) =>
+
+        FormattingConflicts.setFormatterSelector(<T extends FormattingEditProvider>(
+            formatters: T[], document: ITextModel, mode: FormattingMode) =>
             this.selectFormatter(formatters, document, mode));
     }
 
-    private async setDefaultFormatter(language: string, formatter: string): Promise<void> {
+    protected async setDefaultFormatter(language: string, formatter: string): Promise<void> {
         const name = this.preferenceSchema.overridePreferenceName({
             preferenceName: PREFERENCE_NAME,
             overrideIdentifier: language
@@ -63,7 +68,7 @@ export class MonacoFormattingConflictsContribution implements FrontendApplicatio
     }
 
     private async selectFormatter<T extends FormattingEditProvider>(
-        formatters: T[], document: monaco.editor.ITextModel, mode: monaco.format.FormattingMode): Promise<T | undefined> {
+        formatters: T[], document: monaco.editor.ITextModel | ITextModel, mode: FormattingMode): Promise<T | undefined> {
 
         if (formatters.length === 0) {
             return undefined;

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

@@ -15,20 +15,58 @@
 // *****************************************************************************
 
 import { injectable, inject } from '@theia/core/shared/inversify';
-import { FrontendApplicationContribution, PreferenceSchemaProvider } from '@theia/core/lib/browser';
+import { FrontendApplicationContribution, PreferenceSchemaProvider, QuickAccessRegistry } from '@theia/core/lib/browser';
 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';
 
 @injectable()
 export class MonacoFrontendApplicationContribution implements FrontendApplicationContribution {
 
+    @inject(MonacoEditorService)
+    protected readonly codeEditorService: MonacoEditorService;
+
+    @inject(MonacoTextModelService)
+    protected readonly textModelService: MonacoTextModelService;
+
+    @inject(VSCodeContextKeyService)
+    protected readonly contextKeyService: VSCodeContextKeyService;
+
     @inject(MonacoSnippetSuggestProvider)
     protected readonly snippetSuggestProvider: MonacoSnippetSuggestProvider;
 
     @inject(PreferenceSchemaProvider)
     protected readonly preferenceSchema: PreferenceSchemaProvider;
 
+    @inject(QuickAccessRegistry)
+    protected readonly quickAccessRegistry: QuickAccessRegistry;
+
+    @inject(MonacoContextMenuService)
+    protected readonly contextMenuService: MonacoContextMenuService;
+
     async initialize(): Promise<void> {
-        monaco.suggest.setSnippetSuggestSupport(this.snippetSuggestProvider);
+        const { codeEditorService, textModelService, contextKeyService, contextMenuService } = this;
+        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();
+
+        // Incomparability of enum types between public and private API's
+        setSnippetSuggestSupport(this.snippetSuggestProvider as unknown as CompletionItemProvider);
 
         for (const language of monaco.languages.getLanguages()) {
             this.preferenceSchema.registerOverrideIdentifier(language.id);

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

@@ -66,8 +66,12 @@ 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 { Configuration } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configurationModels';
 
-decorate(injectable(), monaco.contextKeyService.ContextKeyService);
+decorate(injectable(), VSCodeContextKeyService);
 
 MonacoThemingService.init();
 
@@ -95,8 +99,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoConfigurationService).toDynamicValue(({ container }) =>
         createMonacoConfigurationService(container)
     ).inSingletonScope();
-    bind(monaco.contextKeyService.ContextKeyService).toDynamicValue(({ container }) =>
-        new monaco.contextKeyService.ContextKeyService(container.get(MonacoConfigurationService))
+    bind(VSCodeContextKeyService).toDynamicValue(({ container }) =>
+        new VSCodeContextKeyService(container.get(MonacoConfigurationService))
     ).inSingletonScope();
 
     bind(MonacoBulkEditService).toSelf().inSingletonScope();
@@ -162,11 +166,11 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
 });
 
 export const MonacoConfigurationService = Symbol('MonacoConfigurationService');
-export function createMonacoConfigurationService(container: interfaces.Container): monaco.services.IConfigurationService {
+export function createMonacoConfigurationService(container: interfaces.Container): IConfigurationService {
     const preferences = container.get<PreferenceService>(PreferenceService);
     const preferenceSchemaProvider = container.get<PreferenceSchemaProvider>(PreferenceSchemaProvider);
-    const service = monaco.services.StaticServices.configurationService.get();
-    const _configuration = service._configuration;
+    const service = StandaloneServices.get(IConfigurationService) as StandaloneConfigurationService;
+    const _configuration: Configuration = service['_configuration'];
 
     _configuration.getValue = (section, overrides) => {
         const overrideIdentifier: string | undefined = (overrides && 'overrideIdentifier' in overrides && typeof overrides.overrideIdentifier === 'string')
@@ -183,12 +187,12 @@ export function createMonacoConfigurationService(container: interfaces.Container
         return proxy;
     };
 
-    const toTarget = (scope: PreferenceScope): monaco.services.ConfigurationTarget => {
+    const toTarget = (scope: PreferenceScope): ConfigurationTarget => {
         switch (scope) {
-            case PreferenceScope.Default: return monaco.services.ConfigurationTarget.DEFAULT;
-            case PreferenceScope.User: return monaco.services.ConfigurationTarget.USER;
-            case PreferenceScope.Workspace: return monaco.services.ConfigurationTarget.WORKSPACE;
-            case PreferenceScope.Folder: return monaco.services.ConfigurationTarget.WORKSPACE_FOLDER;
+            case PreferenceScope.Default: return ConfigurationTarget.DEFAULT;
+            case PreferenceScope.User: return ConfigurationTarget.USER;
+            case PreferenceScope.Workspace: return ConfigurationTarget.WORKSPACE;
+            case PreferenceScope.Folder: return ConfigurationTarget.WORKSPACE_FOLDER;
         }
     };
 
@@ -204,7 +208,7 @@ export function createMonacoConfigurationService(container: interfaces.Container
         keys: new Set<string>(),
         overrides: new Map<string, Set<string>>()
     });
-    const fireDidChangeConfiguration = (source: monaco.services.ConfigurationTarget, context: FireDidChangeConfigurationContext): void => {
+    const fireDidChangeConfiguration = (source: ConfigurationTarget, context: FireDidChangeConfigurationContext): void => {
         if (!context.affectedKeys.size) {
             return;
         }
@@ -212,7 +216,7 @@ export function createMonacoConfigurationService(container: interfaces.Container
         for (const [override, values] of context.overrides) {
             overrides.push([override, [...values]]);
         }
-        service._onDidChangeConfiguration.fire({
+        service['_onDidChangeConfiguration'].fire(<IConfigurationChangeEvent>{
             change: {
                 keys: [...context.keys],
                 overrides
@@ -243,7 +247,7 @@ export function createMonacoConfigurationService(container: interfaces.Container
     };
 
     preferences.onPreferencesChanged(event => {
-        let source: monaco.services.ConfigurationTarget | undefined;
+        let source: ConfigurationTarget | undefined;
         let context = newFireDidChangeConfigurationContext();
         for (let key of Object.keys(event)) {
             const change = event[key];

package/src/browser/monaco-gotoline-quick-access.ts

@@ -16,23 +16,28 @@
 
 import { QuickAccessContribution } from '@theia/core/lib/browser/quick-input';
 import { injectable } from '@theia/core/shared/inversify';
+import { ICodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
+import { StandaloneGotoLineQuickAccessProvider } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess';
+import { IQuickAccessRegistry, Extensions } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickAccess';
+import { Registry } from '@theia/monaco-editor-core/esm/vs/platform/registry/common/platform';
 
-export class GotoLineQuickAccess extends monaco.quickInput.StandaloneGotoLineQuickAccessProvider {
+export class GotoLineQuickAccess extends StandaloneGotoLineQuickAccessProvider {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(...services: any[]);
-    constructor(@monaco.services.ICodeEditorService private readonly service: monaco.editor.ICodeEditorService) {
+    constructor(@ICodeEditorService private readonly service: ICodeEditorService) {
         super(service);
     }
 
-    override get activeTextEditorControl(): monaco.editor.ICodeEditor | undefined {
-        return this.service.getFocusedCodeEditor() || this.service.getActiveCodeEditor();
+    override get activeTextEditorControl(): ICodeEditor | undefined {
+        return (this.service.getFocusedCodeEditor() || this.service.getActiveCodeEditor()) ?? undefined;
     }
 }
 
 @injectable()
 export class GotoLineQuickAccessContribution implements QuickAccessContribution {
     registerQuickAccessProvider(): void {
-        monaco.platform.Registry.as<monaco.quickInput.IQuickAccessRegistry>('workbench.contributions.quickaccess').registerQuickAccessProvider({
+        Registry.as<IQuickAccessRegistry>(Extensions.Quickaccess).registerQuickAccessProvider({
             ctor: GotoLineQuickAccess,
             prefix: ':',
             placeholder: '',

package/src/browser/monaco-gotosymbol-quick-access.ts

@@ -16,23 +16,34 @@
 
 import { QuickAccessContribution } from '@theia/core/lib/browser/quick-input';
 import { injectable } from '@theia/core/shared/inversify';
+import { ICodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
+import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
+import { IOutlineModelService } from '@theia/monaco-editor-core/esm/vs/editor/contrib/documentSymbols/browser/outlineModel';
+import { StandaloneGotoSymbolQuickAccessProvider } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess';
+import { IQuickAccessRegistry, Extensions } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickAccess';
+import { Registry } from '@theia/monaco-editor-core/esm/vs/platform/registry/common/platform';
 
-export class GotoSymbolQuickAccess extends monaco.quickInput.StandaloneGotoSymbolQuickAccessProvider {
+export class GotoSymbolQuickAccess extends StandaloneGotoSymbolQuickAccessProvider {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(...services: any[]);
-    constructor(@monaco.services.ICodeEditorService private readonly service: monaco.editor.ICodeEditorService) {
-        super(service);
+    constructor(
+        @ICodeEditorService protected readonly codeEditorService: ICodeEditorService,
+        @ILanguageFeaturesService protected readonly languageFeatures: ILanguageFeaturesService,
+        @IOutlineModelService protected readonly outlineService: IOutlineModelService,
+    ) {
+        super(codeEditorService, languageFeatures, outlineService);
     }
 
-    override get activeTextEditorControl(): monaco.editor.ICodeEditor | undefined {
-        return this.service.getFocusedCodeEditor() || this.service.getActiveCodeEditor();
+    override get activeTextEditorControl(): ICodeEditor | undefined {
+        return (this.codeEditorService.getFocusedCodeEditor() ?? this.codeEditorService.getActiveCodeEditor()) ?? undefined;
     }
 }
 
 @injectable()
 export class GotoSymbolQuickAccessContribution implements QuickAccessContribution {
     registerQuickAccessProvider(): void {
-        monaco.platform.Registry.as<monaco.quickInput.IQuickAccessRegistry>('workbench.contributions.quickaccess').registerQuickAccessProvider({
+        Registry.as<IQuickAccessRegistry>(Extensions.Quickaccess).registerQuickAccessProvider({
             ctor: GotoSymbolQuickAccess,
             prefix: '@',
             placeholder: '',

package/src/browser/monaco-indexed-db.ts

@@ -17,6 +17,7 @@
 import * as idb from 'idb';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { BuiltinThemeProvider, Theme, ThemeService, ThemeServiceSymbol } from '@theia/core/lib/browser/theming';
+import * as monaco from '@theia/monaco-editor-core';
 type ThemeMix = import('./textmate/monaco-theme-registry').ThemeMix;
 
 let _monacoDB: Promise<idb.IDBPDatabase> | undefined;

package/src/browser/monaco-keybinding.ts

@@ -20,6 +20,7 @@ import { MonacoCommands } from './monaco-command';
 import { MonacoCommandRegistry } from './monaco-command-registry';
 import { environment } from '@theia/core';
 import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
+import { KeybindingsRegistry } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybindingsRegistry';
 
 @injectable()
 export class MonacoKeybindingContribution implements KeybindingContribution {
@@ -28,11 +29,11 @@ export class MonacoKeybindingContribution implements KeybindingContribution {
     protected readonly commands: MonacoCommandRegistry;
 
     registerKeybindings(registry: KeybindingRegistry): void {
-        const defaultKeybindings = monaco.keybindings.KeybindingsRegistry.getDefaultKeybindings();
+        const defaultKeybindings = KeybindingsRegistry.getDefaultKeybindings();
         for (const item of defaultKeybindings) {
             const command = this.commands.validate(item.command);
             if (command) {
-                const when = item.when && item.when.serialize();
+                const when = (item.when && item.when.serialize()) ?? undefined;
                 let keybinding;
                 if (item.command === MonacoCommands.GO_TO_DEFINITION && !environment.electron.is()) {
                     keybinding = 'ctrlcmd+f11';