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

package/src/browser/monaco-quick-input-service.ts

@@ -13,37 +13,68 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
-/* eslint-disable @typescript-eslint/no-explicit-any */
 
 import {
     InputBox, InputOptions, KeybindingRegistry, PickOptions,
-    QuickInputButton, QuickInputService, QuickPick, QuickPickItem,
+    QuickInputButton, QuickInputHideReason, QuickInputService, QuickPick, QuickPickItem,
     QuickPickItemButtonEvent, QuickPickItemHighlights, QuickPickOptions, QuickPickSeparator
 } from '@theia/core/lib/browser';
-import { CancellationToken, Event } from '@theia/core/lib/common';
 import { injectable, inject } from '@theia/core/shared/inversify';
+import {
+    IInputBox, IInputOptions, IKeyMods, IPickOptions, IQuickInput, IQuickInputButton,
+    IQuickInputService, IQuickNavigateConfiguration, IQuickPick, IQuickPickItem, IQuickPickItemButtonEvent, IQuickPickSeparator, QuickPickInput
+} from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickInput';
+import { IQuickInputOptions, IQuickInputStyles, QuickInputController } from '@theia/monaco-editor-core/esm/vs/base/parts/quickinput/browser/quickInput';
 import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
+import { IQuickAccessController } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickAccess';
+import { QuickAccessController } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/browser/quickAccess';
+import { ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
+import { IListOptions, List } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/list/listWidget';
+import * as monaco from '@theia/monaco-editor-core';
+import { ResolvedKeybinding } from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
+import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IMatch } from '@theia/monaco-editor-core/esm/vs/base/common/filters';
+import { IListRenderer, IListVirtualDelegate } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/list/list';
+import { Event } from '@theia/core';
+
+// Copied from @vscode/src/vs/base/parts/quickInput/browser/quickInputList.ts
+export interface IListElement {
+    readonly index: number;
+    readonly item: IQuickPickItem;
+    readonly saneLabel: string;
+    readonly saneAriaLabel: string;
+    readonly saneDescription?: string;
+    readonly saneDetail?: string;
+    readonly labelHighlights?: IMatch[];
+    readonly descriptionHighlights?: IMatch[];
+    readonly detailHighlights?: IMatch[];
+    readonly checked: boolean;
+    readonly separator?: IQuickPickSeparator;
+    readonly fireButtonTriggered: (event: IQuickPickItemButtonEvent<IQuickPickItem>) => void;
+}
 
 @injectable()
-export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickInputService {
+export class MonacoQuickInputImplementation implements IQuickInputService {
+    declare readonly _serviceBrand: undefined;
 
-    controller: monaco.quickInput.QuickInputController;
-    quickAccess: monaco.quickInput.IQuickAccessController;
+    controller: QuickInputController;
+    quickAccess: IQuickAccessController;
 
-    @inject(monaco.contextKeyService.ContextKeyService)
-    protected readonly contextKeyService: monaco.contextKeyService.ContextKeyService;
+    @inject(VSCodeContextKeyService)
+    protected readonly contextKeyService: VSCodeContextKeyService;
 
     protected container: HTMLElement;
-    private quickInputList: monaco.list.List<monaco.list.IListElement>;
+    private quickInputList: List<unknown>;
 
-    get backButton(): monaco.quickInput.IQuickInputButton { return this.controller.backButton; }
-    get onShow(): Event<void> { return this.controller.onShow; }
-    get onHide(): Event<void> { return this.controller.onHide; }
+    get backButton(): IQuickInputButton { return this.controller.backButton; }
+    get onShow(): monaco.IEvent<void> { return this.controller.onShow; }
+    get onHide(): monaco.IEvent<void> { return this.controller.onHide; }
 
     constructor() {
         this.initContainer();
         this.initController();
-        this.quickAccess = new monaco.quickInput.QuickAccessController(this, monaco.services.StaticServices.instantiationService.get());
+        this.quickAccess = new QuickAccessController(this, StandaloneServices.get(IInstantiationService));
     }
 
     setContextKey(key: string | undefined): void {
@@ -52,11 +83,11 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
         }
     }
 
-    createQuickPick<T extends monaco.quickInput.IQuickPickItem>(): monaco.quickInput.IQuickPick<T> {
+    createQuickPick<T extends IQuickPickItem>(): IQuickPick<T> {
         return this.controller.createQuickPick<T>();
     }
 
-    createInputBox(): monaco.quickInput.IInputBox {
+    createInputBox(): IInputBox {
         return this.controller.createInputBox();
     }
 
@@ -67,12 +98,13 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
         }, 300);
     }
 
-    input(options?: monaco.quickInput.IInputOptions, token?: CancellationToken): Promise<string | undefined> {
+    input(options?: IInputOptions, token?: monaco.CancellationToken): Promise<string | undefined> {
         return this.controller.input(options, token);
     }
 
-    pick<T extends monaco.quickInput.IQuickPickItem, O extends monaco.quickInput.IPickOptions<T>>(
-        picks: Promise<T[]> | T[], options: O = <O>{}, token?: CancellationToken): Promise<(O extends { canPickMany: true } ? T[] : T) | undefined> {
+    pick<T extends IQuickPickItem, O extends IPickOptions<T>>(
+        picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options?: O, token?: monaco.CancellationToken
+    ): Promise<(O extends { canPickMany: true; } ? T[] : T) | undefined> {
         return this.controller.pick(picks, options, token);
     }
 
@@ -88,7 +120,7 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
         this.controller.toggle();
     }
 
-    applyStyles(styles: monaco.quickInput.IQuickInputStyles): void {
+    applyStyles(styles: IQuickInputStyles): void {
         this.controller.applyStyles(styles);
     }
 
@@ -96,7 +128,7 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
         this.controller.layout(dimension, titleBarOffset);
     }
 
-    navigate?(next: boolean, quickNavigate?: monaco.quickInput.IQuickNavigateConfiguration): void {
+    navigate(next: boolean, quickNavigate?: IQuickNavigateConfiguration): void {
         this.controller.navigate(next, quickNavigate);
     }
 
@@ -112,7 +144,7 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
         this.controller.back();
     }
 
-    async accept?(keyMods?: monaco.quickInput.IKeyMods): Promise<void> {
+    async accept(keyMods?: IKeyMods): Promise<void> {
         this.controller.accept(keyMods);
     }
 
@@ -129,12 +161,21 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
     }
 
     private initController(): void {
-        this.controller = new monaco.quickInput.QuickInputController(this.getOptions());
+        this.controller = new QuickInputController(this.getOptions());
         this.controller.layout({ width: 600, height: 1200 }, 0);
     }
 
-    private getOptions(): monaco.quickInput.IQuickInputOptions {
-        return {
+    private getOptions(): IQuickInputOptions {
+        const styles: IQuickInputStyles = {
+            widget: {},
+            list: {},
+            inputBox: {},
+            countBadge: {},
+            button: {},
+            progressBar: {},
+            keybindingLabel: {},
+        };
+        const options: IQuickInputOptions = {
             idPrefix: 'quickInput_',
             container: this.container,
             ignoreFocusOut: () => false,
@@ -142,20 +183,12 @@ export class MonacoQuickInputImplementation implements monaco.quickInput.IQuickI
             backKeybindingLabel: () => undefined,
             setContextKey: (id?: string) => this.setContextKey(id),
             returnFocus: () => this.container.focus(),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            createList: (user: string, container: HTMLElement, delegate: any, renderers: any, options: any) => {
-                this.quickInputList = new monaco.list.List(user, container, delegate, renderers, options);
-                return this.quickInputList;
-            },
-            styles: {
-                widget: {},
-                list: {},
-                inputBox: {},
-                countBadge: {},
-                button: {},
-                progressBar: {}
-            }
+            createList: <T>(
+                user: string, container: HTMLElement, delegate: IListVirtualDelegate<T>, renderers: IListRenderer<T, unknown>[], listOptions: IListOptions<T>
+            ): List<T> => this.quickInputList = new List(user, container, delegate, renderers, listOptions),
+            styles,
         };
+        return options;
     }
 }
 
@@ -179,11 +212,11 @@ export class MonacoQuickInputService implements QuickInputService {
     }
 
     createInputBox(): InputBox {
-        return this.monacoService.createInputBox();
+        return this.monacoService.createInputBox() as unknown as InputBox;
     }
 
-    input(options?: InputOptions, token?: CancellationToken): Promise<string | undefined> {
-        let inputOptions: monaco.quickInput.IInputOptions | undefined;
+    input(options?: InputOptions, token?: monaco.CancellationToken): Promise<string | undefined> {
+        let inputOptions: IInputOptions | undefined;
         if (options) {
             const { validateInput, ...props } = options;
             inputOptions = { ...props };
@@ -194,12 +227,19 @@ export class MonacoQuickInputService implements QuickInputService {
         return this.monacoService.input(inputOptions, token);
     }
 
-    pick<T extends QuickPickItem, O extends PickOptions<T>>(picks: T[] | Promise<T[]>, options?: O, token?: CancellationToken):
-        Promise<(O extends { canPickMany: true; } ? T[] : T) | undefined> {
-        return this.monacoService.pick(picks, options, token);
+    async pick<T extends QuickPickItem, O extends PickOptions<T> = PickOptions<T>>(
+        picks: Promise<QuickPickInput<T>[]> | QuickPickInput<T>[], options: O = <O>{}, token?: monaco.CancellationToken
+    ): Promise<(O extends { canPickMany: true; } ? T[] : T) | undefined> {
+        const monacoPicks = (await picks).map(pick => {
+            if (pick.type === 'separator') {
+                return pick;
+            }
+            return this.convertItems(pick);
+        });
+        return this.monacoService.pick(monacoPicks, options as any, token) as any; /* eslint-disable-line @typescript-eslint/no-explicit-any */
     }
 
-    showQuickPick<T extends QuickPickItem>(items: T[], options?: QuickPickOptions<T>): Promise<T> {
+    showQuickPick<T extends QuickPickItem>(items: Array<T | QuickPickSeparator>, options?: QuickPickOptions<T>): Promise<T> {
         return new Promise<T>((resolve, reject) => {
             const quickPick = this.monacoService.createQuickPick<MonacoQuickPickItem<T>>();
             const wrapped = this.wrapQuickPick(quickPick);
@@ -245,7 +285,7 @@ export class MonacoQuickInputService implements QuickInputService {
                         options.onDidChangeActive(wrapped, activeItems);
                     }
                 });
-                wrapped.onDidTriggerButton((button: monaco.quickInput.IQuickInputButton) => {
+                wrapped.onDidTriggerButton((button: IQuickInputButton) => {
                     if (options.onDidTriggerButton) {
                         options.onDidTriggerButton(button);
                     }
@@ -285,7 +325,7 @@ export class MonacoQuickInputService implements QuickInputService {
         return this.wrapQuickPick(quickPick);
     }
 
-    wrapQuickPick<T extends QuickPickItem>(wrapped: monaco.quickInput.IQuickPick<MonacoQuickPickItem<T>>): QuickPick<T> {
+    wrapQuickPick<T extends QuickPickItem>(wrapped: IQuickPick<MonacoQuickPickItem<T>>): QuickPick<T> {
         return new MonacoQuickPick(wrapped, this.keybindingRegistry);
     }
 
@@ -299,11 +339,11 @@ export class MonacoQuickInputService implements QuickInputService {
 }
 
 class MonacoQuickInput {
-    constructor(protected readonly wrapped: monaco.quickInput.IQuickInput) {
+    constructor(protected readonly wrapped: IQuickInput) {
     }
 
-    readonly onDidHide: Event<void> = this.wrapped.onDidHide;
-    readonly onDispose: Event<void> = this.wrapped.onDispose;
+    get onDidHide(): Event<{ reason: QuickInputHideReason }> { return this.wrapped.onDidHide; }
+    get onDispose(): Event<void> { return this.wrapped.onDispose; }
 
     get title(): string | undefined {
         return this.wrapped.title;
@@ -379,7 +419,7 @@ class MonacoQuickInput {
 }
 
 class MonacoQuickPick<T extends QuickPickItem> extends MonacoQuickInput implements QuickPick<T> {
-    constructor(protected override readonly wrapped: monaco.quickInput.IQuickPick<MonacoQuickPickItem<T>>, protected readonly keybindingRegistry: KeybindingRegistry) {
+    constructor(protected override readonly wrapped: IQuickPick<MonacoQuickPickItem<T>>, protected readonly keybindingRegistry: KeybindingRegistry) {
         super(wrapped);
     }
 
@@ -447,29 +487,32 @@ class MonacoQuickPick<T extends QuickPickItem> extends MonacoQuickInput implemen
         return this.wrapped.selectedItems.map(item => item.item);
     }
 
-    readonly onDidAccept: Event<void> = this.wrapped.onDidAccept;
+    readonly onDidAccept: Event<{ inBackground: boolean }> = this.wrapped.onDidAccept;
     readonly onDidChangeValue: Event<string> = this.wrapped.onDidChangeValue;
     readonly onDidTriggerButton: Event<QuickInputButton> = this.wrapped.onDidTriggerButton;
     readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<T>> =
-        Event.map(this.wrapped.onDidTriggerItemButton, (evt: monaco.quickInput.IQuickPickItemButtonEvent<MonacoQuickPickItem<T>>) => ({
+        Event.map(this.wrapped.onDidTriggerItemButton, (evt: IQuickPickItemButtonEvent<MonacoQuickPickItem<T>>) => ({
             item: evt.item.item,
             button: evt.button
         }));
-    readonly onDidChangeActive: Event<T[]> = Event.map(this.wrapped.onDidChangeActive, (items: MonacoQuickPickItem<T>[]) => items.map(item => item.item));
-    readonly onDidChangeSelection: Event<T[]> = Event.map(this.wrapped.onDidChangeSelection, (items: MonacoQuickPickItem<T>[]) => items.map(item => item.item));
+    readonly onDidChangeActive: Event<T[]> = Event.map(
+        this.wrapped.onDidChangeActive,
+        (items: MonacoQuickPickItem<T>[]) => items.map(item => item.item));
+    readonly onDidChangeSelection: Event<T[]> = Event.map(
+        this.wrapped.onDidChangeSelection, (items: MonacoQuickPickItem<T>[]) => items.map(item => item.item));
 }
 
-export class MonacoQuickPickItem<T extends QuickPickItem> implements monaco.quickInput.IQuickPickItem {
-    readonly type?: 'item' | 'separator';
+export class MonacoQuickPickItem<T extends QuickPickItem> implements IQuickPickItem {
+    readonly type?: 'item';
     readonly id?: string;
     readonly label: string;
     readonly meta?: string;
     readonly ariaLabel?: string;
     readonly description?: string;
     readonly detail?: string;
-    readonly keybinding?: monaco.keybindings.ResolvedKeybinding;
+    readonly keybinding?: ResolvedKeybinding;
     readonly iconClasses?: string[];
-    buttons?: monaco.quickInput.IQuickInputButton[];
+    buttons?: IQuickInputButton[];
     readonly alwaysShow?: boolean;
     readonly highlights?: QuickPickItemHighlights;
 
@@ -483,7 +526,7 @@ export class MonacoQuickPickItem<T extends QuickPickItem> implements monaco.quic
         this.detail = item.detail;
         this.keybinding = item.keySequence ? new MonacoResolvedKeybinding(item.keySequence, kbRegistry) : undefined;
         this.iconClasses = item.iconClasses;
-        this.buttons = item.buttons;
+        this.buttons = item.buttons?.map(QuickInputButton.normalize);
         this.alwaysShow = item.alwaysShow;
         this.highlights = item.highlights;
     }

package/src/browser/monaco-resolved-keybinding.ts

@@ -14,14 +14,21 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { KeyCode as MonacoKeyCode } from '@theia/monaco-editor-core/esm/vs/base/common/keyCodes';
+import {
+    ChordKeybinding, KeybindingModifier, ResolvedKeybinding, ResolvedKeybindingPart, ScanCodeBinding, SimpleKeybinding
+} from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
+import { ElectronAcceleratorLabelProvider, UILabelProvider, UserSettingsLabelProvider } from '@theia/monaco-editor-core/esm/vs/base/common/keybindingLabels';
+import { USLayoutResolvedKeybinding } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/usLayoutResolvedKeybinding';
+import * as MonacoPlatform from '@theia/monaco-editor-core/esm/vs/base/common/platform';
 import { KeybindingRegistry } from '@theia/core/lib/browser/keybinding';
 import { KeyCode, KeySequence, Keystroke, Key, KeyModifier } from '@theia/core/lib/browser/keys';
 import { isOSX } from '@theia/core/lib/common/os';
 import { KEY_CODE_MAP } from './monaco-keycode-map';
 
-export class MonacoResolvedKeybinding extends monaco.keybindings.ResolvedKeybinding {
+export class MonacoResolvedKeybinding extends ResolvedKeybinding {
 
-    protected readonly parts: monaco.keybindings.ResolvedKeybindingPart[];
+    protected readonly parts: ResolvedKeybindingPart[];
 
     constructor(protected readonly keySequence: KeySequence, keybindingService: KeybindingRegistry) {
         super();
@@ -29,7 +36,7 @@ export class MonacoResolvedKeybinding extends monaco.keybindings.ResolvedKeybind
             // eslint-disable-next-line no-null/no-null
             const keyLabel = keyCode.key ? keybindingService.acceleratorForKey(keyCode.key) : null;
             const keyAriaLabel = keyLabel;
-            return new monaco.keybindings.ResolvedKeybindingPart(
+            return new ResolvedKeybindingPart(
                 keyCode.ctrl,
                 keyCode.shift,
                 keyCode.alt,
@@ -40,45 +47,64 @@ export class MonacoResolvedKeybinding extends monaco.keybindings.ResolvedKeybind
         });
     }
 
-    public getLabel(): string | null {
-        return monaco.keybindings.UILabelProvider.toLabel(monaco.platform.OS, this.parts, p => p.keyLabel);
+    getLabel(): string | null {
+        return UILabelProvider.toLabel(MonacoPlatform.OS, this.parts, p => p.keyLabel);
     }
 
-    public getAriaLabel(): string | null {
-        return monaco.keybindings.UILabelProvider.toLabel(monaco.platform.OS, this.parts, p => p.keyAriaLabel);
+    getAriaLabel(): string | null {
+        return UILabelProvider.toLabel(MonacoPlatform.OS, this.parts, p => p.keyAriaLabel);
     }
 
-    public getElectronAccelerator(): string | null {
+    getElectronAccelerator(): string | null {
         if (this.isChord()) {
             // Electron cannot handle chords
             // eslint-disable-next-line no-null/no-null
             return null;
         }
-        return monaco.keybindings.ElectronAcceleratorLabelProvider.toLabel(monaco.platform.OS, this.parts, p => p.keyLabel);
+        return ElectronAcceleratorLabelProvider.toLabel(MonacoPlatform.OS, this.parts, p => p.keyLabel);
     }
 
-    public getUserSettingsLabel(): string | null {
-        return monaco.keybindings.UserSettingsLabelProvider.toLabel(monaco.platform.OS, this.parts, p => p.keyLabel);
+    getUserSettingsLabel(): string | null {
+        return UserSettingsLabelProvider.toLabel(MonacoPlatform.OS, this.parts, p => p.keyLabel);
     }
 
-    public isWYSIWYG(): boolean {
+    isWYSIWYG(): boolean {
         return true;
     }
 
-    public isChord(): boolean {
+    isChord(): boolean {
         return this.parts.length > 1;
     }
 
-    public getDispatchParts(): (string | null)[] {
-        return this.keySequence.map(keyCode => monaco.keybindings.USLayoutResolvedKeybinding.getDispatchStr(this.toKeybinding(keyCode)));
+    getDispatchParts(): (string | null)[] {
+        return this.keySequence.map(keyCode => USLayoutResolvedKeybinding.getDispatchStr(this.toKeybinding(keyCode)));
     }
 
-    public getSingleModifierDispatchParts(): (string | null)[] {
-        return []; /* NOOP */
+    getSingleModifierDispatchParts(): (KeybindingModifier | null)[] {
+        return this.keySequence.map(keybinding => this.getSingleModifierDispatchPart(keybinding));
     }
 
-    private toKeybinding(keyCode: KeyCode): monaco.keybindings.SimpleKeybinding {
-        return new monaco.keybindings.SimpleKeybinding(
+    protected getSingleModifierDispatchPart(code: KeyCode): KeybindingModifier | null {
+        if (code.key?.keyCode === undefined) {
+            return null; // eslint-disable-line no-null/no-null
+        }
+        if (KEY_CODE_MAP[code.key?.keyCode] === MonacoKeyCode.Ctrl && !code.shift && !code.alt && !code.meta) {
+            return 'ctrl';
+        }
+        if (KEY_CODE_MAP[code.key?.keyCode] === MonacoKeyCode.Shift && !code.ctrl && !code.alt && !code.meta) {
+            return 'shift';
+        }
+        if (KEY_CODE_MAP[code.key?.keyCode] === MonacoKeyCode.Alt && !code.shift && !code.ctrl && !code.meta) {
+            return 'alt';
+        }
+        if (KEY_CODE_MAP[code.key?.keyCode] === MonacoKeyCode.Meta && !code.shift && !code.alt && !code.ctrl) {
+            return 'meta';
+        }
+        return null; // eslint-disable-line no-null/no-null
+    }
+
+    private toKeybinding(keyCode: KeyCode): SimpleKeybinding {
+        return new SimpleKeybinding(
             keyCode.ctrl,
             keyCode.shift,
             keyCode.alt,
@@ -87,18 +113,16 @@ export class MonacoResolvedKeybinding extends monaco.keybindings.ResolvedKeybind
         );
     }
 
-    public getParts(): monaco.keybindings.ResolvedKeybindingPart[] {
+    public getParts(): ResolvedKeybindingPart[] {
         return this.parts;
     }
 
-    static toKeybinding(keybinding: monaco.keybindings.Keybinding): string {
-        return keybinding instanceof monaco.keybindings.SimpleKeybinding
-            ? this.keyCode(keybinding).toString()
-            : this.keySequence(keybinding as monaco.keybindings.ChordKeybinding).join(' ');
+    static toKeybinding(keybindings: Array<SimpleKeybinding | ScanCodeBinding>): string {
+        return keybindings.map(binding => this.keyCode(binding)).join(' ');
     }
 
-    static keyCode(keybinding: monaco.keybindings.SimpleKeybinding): KeyCode {
-        const keyCode = keybinding.keyCode;
+    static keyCode(keybinding: SimpleKeybinding | ScanCodeBinding): KeyCode {
+        const keyCode = keybinding instanceof SimpleKeybinding ? keybinding.keyCode : USLayoutResolvedKeybinding['_scanCodeToKeyCode'](keybinding.scanCode);
         const sequence: Keystroke = {
             first: Key.getKey(this.monaco2BrowserKeyCode(keyCode & 0xff)),
             modifiers: []
@@ -122,11 +146,11 @@ export class MonacoResolvedKeybinding extends monaco.keybindings.ResolvedKeybind
         return KeyCode.createKeyCode(sequence);
     }
 
-    static keySequence(keybinding: monaco.keybindings.ChordKeybinding): KeySequence {
+    static keySequence(keybinding: ChordKeybinding): KeySequence {
         return keybinding.parts.map(part => this.keyCode(part));
     }
 
-    private static monaco2BrowserKeyCode(keyCode: monaco.KeyCode): number {
+    private static monaco2BrowserKeyCode(keyCode: MonacoKeyCode): number {
         for (let i = 0; i < KEY_CODE_MAP.length; i++) {
             if (KEY_CODE_MAP[i] === keyCode) {
                 return i;

package/src/browser/monaco-snippet-suggest-provider.ts

@@ -24,6 +24,8 @@ import URI from '@theia/core/lib/common/uri';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileOperationError } from '@theia/filesystem/lib/common/files';
+import * as monaco from '@theia/monaco-editor-core';
+import { SnippetParser } from '@theia/monaco-editor-core/esm/vs/editor/contrib/snippet/browser/snippetParser';
 
 @injectable()
 export class MonacoSnippetSuggestProvider implements monaco.languages.CompletionItemProvider {
@@ -49,13 +51,13 @@ export class MonacoSnippetSuggestProvider implements monaco.languages.Completion
             return undefined;
         }
 
-        const languageId = model.getModeId(); // TODO: look up a language id at the position
+        const languageId = model.getLanguageId(); // TODO: look up a language id at the position
         await this.loadSnippets(languageId);
         const snippetsForLanguage = this.snippets.get(languageId) || [];
 
         const pos = { lineNumber: position.lineNumber, column: 1 };
         const lineOffsets: number[] = [];
-        const linePrefixLow = model.getLineContent(position.lineNumber).substr(0, position.column - 1).toLowerCase();
+        const linePrefixLow = model.getLineContent(position.lineNumber).substring(0, position.column - 1).toLowerCase();
         const endsInWhitespace = linePrefixLow.match(/\s$/);
 
         while (pos.column < position.column) {
@@ -287,7 +289,7 @@ export class MonacoSnippetSuggestion implements monaco.languages.CompletionItem
     protected resolved = false;
     resolve(): MonacoSnippetSuggestion {
         if (!this.resolved) {
-            const codeSnippet = new monaco.snippetParser.SnippetParser().parse(this.snippet.body).toString();
+            const codeSnippet = new SnippetParser().parse(this.snippet.body).toString();
             this.documentation = { value: '```\n' + codeSnippet + '```' };
             this.resolved = true;
         }

package/src/browser/monaco-status-bar-contribution.ts

@@ -19,6 +19,7 @@ import { DisposableCollection, nls } from '@theia/core';
 import { FrontendApplicationContribution, FrontendApplication, StatusBar, StatusBarAlignment } from '@theia/core/lib/browser';
 import { EditorCommands, EditorManager, EditorWidget } from '@theia/editor/lib/browser';
 import { MonacoEditor } from './monaco-editor';
+import * as monaco from '@theia/monaco-editor-core';
 
 @injectable()
 export class MonacoStatusBarContribution implements FrontendApplicationContribution {
@@ -101,7 +102,7 @@ export class MonacoStatusBarContribution implements FrontendApplicationContribut
         this.statusBar.removeElement('editor-status-eol');
     }
 
-    protected getModel(editor: EditorWidget | undefined): monaco.editor.IModel | undefined {
+    protected getModel(editor: EditorWidget | undefined): monaco.editor.ITextModel | undefined {
         const monacoEditor = MonacoEditor.get(editor);
         return monacoEditor && monacoEditor.getControl().getModel() || undefined;
     }