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

package/src/browser/monaco-keycode-map.ts

@@ -19,10 +19,11 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as browser from '@theia/core/lib/browser';
+// This is exported as part of the public API, but we use it with private API's so we need to refer to the private version.
+import { KeyCode } from '@theia/monaco-editor-core/esm/vs/base/common/keyCodes';
+import * as MonacoPlatform from '@theia/monaco-editor-core/esm/vs/base/common/platform';
 
-const KeyCode = monaco.KeyCode;
-
-export const KEY_CODE_MAP: monaco.KeyCode[] = [];
+export const KEY_CODE_MAP: KeyCode[] = [];
 (function (): void {
     KEY_CODE_MAP[3] = KeyCode.PauseBreak; // VK_CANCEL 0x03 Control-break processing
     KEY_CODE_MAP[8] = KeyCode.Backspace;
@@ -46,62 +47,62 @@ export const KEY_CODE_MAP: monaco.KeyCode[] = [];
     KEY_CODE_MAP[45] = KeyCode.Insert;
     KEY_CODE_MAP[46] = KeyCode.Delete;
 
-    KEY_CODE_MAP[48] = KeyCode.KEY_0;
-    KEY_CODE_MAP[49] = KeyCode.KEY_1;
-    KEY_CODE_MAP[50] = KeyCode.KEY_2;
-    KEY_CODE_MAP[51] = KeyCode.KEY_3;
-    KEY_CODE_MAP[52] = KeyCode.KEY_4;
-    KEY_CODE_MAP[53] = KeyCode.KEY_5;
-    KEY_CODE_MAP[54] = KeyCode.KEY_6;
-    KEY_CODE_MAP[55] = KeyCode.KEY_7;
-    KEY_CODE_MAP[56] = KeyCode.KEY_8;
-    KEY_CODE_MAP[57] = KeyCode.KEY_9;
+    KEY_CODE_MAP[48] = KeyCode.Digit0;
+    KEY_CODE_MAP[49] = KeyCode.Digit1;
+    KEY_CODE_MAP[50] = KeyCode.Digit2;
+    KEY_CODE_MAP[51] = KeyCode.Digit3;
+    KEY_CODE_MAP[52] = KeyCode.Digit4;
+    KEY_CODE_MAP[53] = KeyCode.Digit5;
+    KEY_CODE_MAP[54] = KeyCode.Digit6;
+    KEY_CODE_MAP[55] = KeyCode.Digit7;
+    KEY_CODE_MAP[56] = KeyCode.Digit8;
+    KEY_CODE_MAP[57] = KeyCode.Digit9;
 
-    KEY_CODE_MAP[65] = KeyCode.KEY_A;
-    KEY_CODE_MAP[66] = KeyCode.KEY_B;
-    KEY_CODE_MAP[67] = KeyCode.KEY_C;
-    KEY_CODE_MAP[68] = KeyCode.KEY_D;
-    KEY_CODE_MAP[69] = KeyCode.KEY_E;
-    KEY_CODE_MAP[70] = KeyCode.KEY_F;
-    KEY_CODE_MAP[71] = KeyCode.KEY_G;
-    KEY_CODE_MAP[72] = KeyCode.KEY_H;
-    KEY_CODE_MAP[73] = KeyCode.KEY_I;
-    KEY_CODE_MAP[74] = KeyCode.KEY_J;
-    KEY_CODE_MAP[75] = KeyCode.KEY_K;
-    KEY_CODE_MAP[76] = KeyCode.KEY_L;
-    KEY_CODE_MAP[77] = KeyCode.KEY_M;
-    KEY_CODE_MAP[78] = KeyCode.KEY_N;
-    KEY_CODE_MAP[79] = KeyCode.KEY_O;
-    KEY_CODE_MAP[80] = KeyCode.KEY_P;
-    KEY_CODE_MAP[81] = KeyCode.KEY_Q;
-    KEY_CODE_MAP[82] = KeyCode.KEY_R;
-    KEY_CODE_MAP[83] = KeyCode.KEY_S;
-    KEY_CODE_MAP[84] = KeyCode.KEY_T;
-    KEY_CODE_MAP[85] = KeyCode.KEY_U;
-    KEY_CODE_MAP[86] = KeyCode.KEY_V;
-    KEY_CODE_MAP[87] = KeyCode.KEY_W;
-    KEY_CODE_MAP[88] = KeyCode.KEY_X;
-    KEY_CODE_MAP[89] = KeyCode.KEY_Y;
-    KEY_CODE_MAP[90] = KeyCode.KEY_Z;
+    KEY_CODE_MAP[65] = KeyCode.KeyA;
+    KEY_CODE_MAP[66] = KeyCode.KeyB;
+    KEY_CODE_MAP[67] = KeyCode.KeyC;
+    KEY_CODE_MAP[68] = KeyCode.KeyD;
+    KEY_CODE_MAP[69] = KeyCode.KeyE;
+    KEY_CODE_MAP[70] = KeyCode.KeyF;
+    KEY_CODE_MAP[71] = KeyCode.KeyG;
+    KEY_CODE_MAP[72] = KeyCode.KeyH;
+    KEY_CODE_MAP[73] = KeyCode.KeyI;
+    KEY_CODE_MAP[74] = KeyCode.KeyJ;
+    KEY_CODE_MAP[75] = KeyCode.KeyK;
+    KEY_CODE_MAP[76] = KeyCode.KeyL;
+    KEY_CODE_MAP[77] = KeyCode.KeyM;
+    KEY_CODE_MAP[78] = KeyCode.KeyN;
+    KEY_CODE_MAP[79] = KeyCode.KeyO;
+    KEY_CODE_MAP[80] = KeyCode.KeyP;
+    KEY_CODE_MAP[81] = KeyCode.KeyQ;
+    KEY_CODE_MAP[82] = KeyCode.KeyR;
+    KEY_CODE_MAP[83] = KeyCode.KeyS;
+    KEY_CODE_MAP[84] = KeyCode.KeyT;
+    KEY_CODE_MAP[85] = KeyCode.KeyU;
+    KEY_CODE_MAP[86] = KeyCode.KeyV;
+    KEY_CODE_MAP[87] = KeyCode.KeyW;
+    KEY_CODE_MAP[88] = KeyCode.KeyX;
+    KEY_CODE_MAP[89] = KeyCode.KeyY;
+    KEY_CODE_MAP[90] = KeyCode.KeyZ;
 
     KEY_CODE_MAP[93] = KeyCode.ContextMenu;
 
-    KEY_CODE_MAP[96] = KeyCode.NUMPAD_0;
-    KEY_CODE_MAP[97] = KeyCode.NUMPAD_1;
-    KEY_CODE_MAP[98] = KeyCode.NUMPAD_2;
-    KEY_CODE_MAP[99] = KeyCode.NUMPAD_3;
-    KEY_CODE_MAP[100] = KeyCode.NUMPAD_4;
-    KEY_CODE_MAP[101] = KeyCode.NUMPAD_5;
-    KEY_CODE_MAP[102] = KeyCode.NUMPAD_6;
-    KEY_CODE_MAP[103] = KeyCode.NUMPAD_7;
-    KEY_CODE_MAP[104] = KeyCode.NUMPAD_8;
-    KEY_CODE_MAP[105] = KeyCode.NUMPAD_9;
-    KEY_CODE_MAP[106] = KeyCode.NUMPAD_MULTIPLY;
-    KEY_CODE_MAP[107] = KeyCode.NUMPAD_ADD;
+    KEY_CODE_MAP[96] = KeyCode.Numpad0;
+    KEY_CODE_MAP[97] = KeyCode.Numpad1;
+    KEY_CODE_MAP[98] = KeyCode.Numpad2;
+    KEY_CODE_MAP[99] = KeyCode.Numpad3;
+    KEY_CODE_MAP[100] = KeyCode.Numpad4;
+    KEY_CODE_MAP[101] = KeyCode.Numpad5;
+    KEY_CODE_MAP[102] = KeyCode.Numpad6;
+    KEY_CODE_MAP[103] = KeyCode.Numpad7;
+    KEY_CODE_MAP[104] = KeyCode.Numpad8;
+    KEY_CODE_MAP[105] = KeyCode.Numpad9;
+    KEY_CODE_MAP[106] = KeyCode.NumpadMultiply;
+    KEY_CODE_MAP[107] = KeyCode.NumpadAdd;
     KEY_CODE_MAP[108] = KeyCode.NUMPAD_SEPARATOR;
-    KEY_CODE_MAP[109] = KeyCode.NUMPAD_SUBTRACT;
-    KEY_CODE_MAP[110] = KeyCode.NUMPAD_DECIMAL;
-    KEY_CODE_MAP[111] = KeyCode.NUMPAD_DIVIDE;
+    KEY_CODE_MAP[109] = KeyCode.NumpadSubtract;
+    KEY_CODE_MAP[110] = KeyCode.NumpadDecimal;
+    KEY_CODE_MAP[111] = KeyCode.NumpadDivide;
 
     KEY_CODE_MAP[112] = KeyCode.F1;
     KEY_CODE_MAP[113] = KeyCode.F2;
@@ -126,22 +127,22 @@ export const KEY_CODE_MAP: monaco.KeyCode[] = [];
     KEY_CODE_MAP[144] = KeyCode.NumLock;
     KEY_CODE_MAP[145] = KeyCode.ScrollLock;
 
-    KEY_CODE_MAP[186] = KeyCode.US_SEMICOLON;
-    KEY_CODE_MAP[187] = KeyCode.US_EQUAL;
-    KEY_CODE_MAP[188] = KeyCode.US_COMMA;
-    KEY_CODE_MAP[189] = KeyCode.US_MINUS;
-    KEY_CODE_MAP[190] = KeyCode.US_DOT;
-    KEY_CODE_MAP[191] = KeyCode.US_SLASH;
-    KEY_CODE_MAP[192] = KeyCode.US_BACKTICK;
+    KEY_CODE_MAP[186] = KeyCode.Semicolon;
+    KEY_CODE_MAP[187] = KeyCode.Equal;
+    KEY_CODE_MAP[188] = KeyCode.Comma;
+    KEY_CODE_MAP[189] = KeyCode.Minus;
+    KEY_CODE_MAP[190] = KeyCode.Period;
+    KEY_CODE_MAP[191] = KeyCode.Slash;
+    KEY_CODE_MAP[192] = KeyCode.Backquote;
     KEY_CODE_MAP[193] = KeyCode.ABNT_C1;
     KEY_CODE_MAP[194] = KeyCode.ABNT_C2;
-    KEY_CODE_MAP[219] = KeyCode.US_OPEN_SQUARE_BRACKET;
-    KEY_CODE_MAP[220] = KeyCode.US_BACKSLASH;
-    KEY_CODE_MAP[221] = KeyCode.US_CLOSE_SQUARE_BRACKET;
-    KEY_CODE_MAP[222] = KeyCode.US_QUOTE;
+    KEY_CODE_MAP[219] = KeyCode.BracketLeft;
+    KEY_CODE_MAP[220] = KeyCode.Backslash;
+    KEY_CODE_MAP[221] = KeyCode.BracketRight;
+    KEY_CODE_MAP[222] = KeyCode.Quote;
     KEY_CODE_MAP[223] = KeyCode.OEM_8;
 
-    KEY_CODE_MAP[226] = KeyCode.OEM_102;
+    KEY_CODE_MAP[226] = KeyCode.IntlBackslash;
 
     /**
      * https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html
@@ -152,15 +153,15 @@ export const KEY_CODE_MAP: monaco.KeyCode[] = [];
     if (browser.isIE) {
         KEY_CODE_MAP[91] = KeyCode.Meta;
     } else if (browser.isFirefox) {
-        KEY_CODE_MAP[59] = KeyCode.US_SEMICOLON;
-        KEY_CODE_MAP[107] = KeyCode.US_EQUAL;
-        KEY_CODE_MAP[109] = KeyCode.US_MINUS;
-        if (monaco.platform.OS === monaco.platform.OperatingSystem.Macintosh) {
+        KEY_CODE_MAP[59] = KeyCode.Semicolon;
+        KEY_CODE_MAP[107] = KeyCode.Equal;
+        KEY_CODE_MAP[109] = KeyCode.Minus;
+        if (MonacoPlatform.OS === MonacoPlatform.OperatingSystem.Macintosh) {
             KEY_CODE_MAP[224] = KeyCode.Meta;
         }
     } else if (browser.isWebKit) {
         KEY_CODE_MAP[91] = KeyCode.Meta;
-        if (monaco.platform.OS === monaco.platform.OperatingSystem.Macintosh) {
+        if (MonacoPlatform.OS === MonacoPlatform.OperatingSystem.Macintosh) {
             // the two meta keys in the Mac have different key codes (91 and 93)
             KEY_CODE_MAP[93] = KeyCode.Meta;
         } else {

package/src/browser/monaco-languages.ts

@@ -24,6 +24,7 @@ import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { Language, LanguageService } from '@theia/core/lib/browser/language-service';
 import { MonacoDiagnosticCollection } from './monaco-diagnostic-collection';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
+import * as monaco from '@theia/monaco-editor-core';
 
 export interface WorkspaceSymbolProvider {
     provideWorkspaceSymbols(params: WorkspaceSymbolParams, token: CancellationToken): MaybePromise<SymbolInformation[] | undefined>;

package/src/browser/monaco-menu.ts

@@ -19,7 +19,7 @@ import { MenuContribution, MenuModelRegistry, MAIN_MENU_BAR, MenuPath } from '@t
 import { EditorMainMenu, EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
 import { MonacoCommandRegistry } from './monaco-command-registry';
 import { nls } from '@theia/core/lib/common/nls';
-import MenuRegistry = monaco.actions.MenuRegistry;
+import { isIMenuItem, MenuId, MenuRegistry } from '@theia/monaco-editor-core/esm/vs/platform/actions/common/actions';
 
 export interface MonacoActionGroup {
     id: string;
@@ -39,8 +39,8 @@ export class MonacoEditorMenuContribution implements MenuContribution {
     ) { }
 
     registerMenus(registry: MenuModelRegistry): void {
-        for (const item of MenuRegistry.getMenuItems(monaco.actions.MenuId.EditorContext)) {
-            if (!monaco.actions.isIMenuItem(item)) {
+        for (const item of MenuRegistry.getMenuItems(MenuId.EditorContext)) {
+            if (!isIMenuItem(item)) {
                 continue;
             }
             const commandId = this.commands.validate(item.command.id);
@@ -53,8 +53,8 @@ export class MonacoEditorMenuContribution implements MenuContribution {
         this.registerPeekSubmenu(registry);
 
         registry.registerSubmenu(MonacoMenus.SELECTION, nls.localizeByDefault('Selection'));
-        for (const item of MenuRegistry.getMenuItems(monaco.actions.MenuId.MenubarSelectionMenu)) {
-            if (!monaco.actions.isIMenuItem(item)) {
+        for (const item of MenuRegistry.getMenuItems(MenuId.MenubarSelectionMenu)) {
+            if (!isIMenuItem(item)) {
                 continue;
             }
             const commandId = this.commands.validate(item.command.id);
@@ -115,8 +115,8 @@ export class MonacoEditorMenuContribution implements MenuContribution {
     protected registerPeekSubmenu(registry: MenuModelRegistry): void {
         registry.registerSubmenu(MonacoMenus.PEEK_CONTEXT_SUBMENU, nls.localizeByDefault('Peek'));
 
-        for (const item of MenuRegistry.getMenuItems(monaco.actions.MenuId.EditorContextPeek)) {
-            if (!monaco.actions.isIMenuItem(item)) {
+        for (const item of MenuRegistry.getMenuItems(MenuId.EditorContextPeek)) {
+            if (!isIMenuItem(item)) {
                 continue;
             }
             const commandId = this.commands.validate(item.command.id);

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

@@ -17,6 +17,11 @@
 import debounce = require('@theia/core/shared/lodash.debounce');
 import { injectable } from '@theia/core/shared/inversify';
 import { MimeAssociation, MimeService } from '@theia/core/lib/browser/mime-service';
+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 * as monaco from '@theia/monaco-editor-core';
+import { clearConfiguredLanguageAssociations, registerConfiguredLanguageAssociation } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languagesAssociations';
+import { LanguageService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageService';
 
 @injectable()
 export class MonacoMimeService extends MimeService {
@@ -26,7 +31,7 @@ export class MonacoMimeService extends MimeService {
 
     constructor() {
         super();
-        monaco.services.StaticServices.modeService.get()._onLanguagesMaybeChanged.event(() => {
+        StandaloneServices.get(ILanguageService).onDidChange(() => {
             if (this.updatingAssociations) {
                 return;
             }
@@ -42,14 +47,13 @@ export class MonacoMimeService extends MimeService {
     protected updateAssociations = debounce(() => {
         this.updatingAssociations = true;
         try {
-            monaco.mime.clearTextMimes(true);
+            clearConfiguredLanguageAssociations();
 
             for (const association of this.associations) {
                 const mimetype = this.getMimeForMode(association.id) || `text/x-${association.id}`;
-                monaco.mime.registerTextMime({ id: association.id, mime: mimetype, filepattern: association.filepattern, userConfigured: true }, false);
+                registerConfiguredLanguageAssociation({ id: association.id, mime: mimetype, filepattern: association.filepattern });
             }
-
-            monaco.services.StaticServices.modeService.get()._onLanguagesMaybeChanged.fire(undefined);
+            (StandaloneServices.get(ILanguageService) as LanguageService)['_onDidChange'].fire(undefined);
         } finally {
             this.updatingAssociations = false;
         }

package/src/browser/monaco-outline-contribution.ts

@@ -15,20 +15,19 @@
 // *****************************************************************************
 
 import { injectable, inject } from '@theia/core/shared/inversify';
-import DocumentSymbol = monaco.languages.DocumentSymbol;
-import SymbolKind = monaco.languages.SymbolKind;
 import { FrontendApplicationContribution, FrontendApplication, TreeNode } from '@theia/core/lib/browser';
 import { Range, EditorManager, EditorOpenerOptions } from '@theia/editor/lib/browser';
-import DocumentSymbolProviderRegistry = monaco.modes.DocumentSymbolProviderRegistry;
-import CancellationTokenSource = monaco.CancellationTokenSource;
-import CancellationToken = monaco.CancellationToken;
 import { DisposableCollection, Disposable } from '@theia/core';
 import { OutlineViewService } from '@theia/outline-view/lib/browser/outline-view-service';
 import { OutlineSymbolInformationNode } from '@theia/outline-view/lib/browser/outline-view-widget';
 import URI from '@theia/core/lib/common/uri';
 import { MonacoEditor } from './monaco-editor';
-
 import debounce = require('@theia/core/shared/lodash.debounce');
+import * as monaco from '@theia/monaco-editor-core';
+import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { DocumentSymbol } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
 
 @injectable()
 export class MonacoOutlineContribution implements FrontendApplicationContribution {
@@ -44,7 +43,7 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
 
         // updateOutline and handleCurrentEditorChanged need to be called even when the outline view widget is closed
         // in order to update breadcrumbs.
-        DocumentSymbolProviderRegistry.onDidChange(
+        StandaloneServices.get(ILanguageFeaturesService).documentSymbolProvider.onDidChange(
             debounce(() => this.updateOutline())
         );
         this.editorManager.onCurrentEditorChanged(
@@ -100,13 +99,13 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         this.updateOutline();
     }
 
-    protected tokenSource = new CancellationTokenSource();
+    protected tokenSource = new monaco.CancellationTokenSource();
     protected async updateOutline(editorSelection?: Range): Promise<void> {
         if (!this.canUpdateOutline) {
             return;
         }
         this.tokenSource.cancel();
-        this.tokenSource = new CancellationTokenSource();
+        this.tokenSource = new monaco.CancellationTokenSource();
         const token = this.tokenSource.token;
 
         const editor = MonacoEditor.get(this.editorManager.currentEditor);
@@ -118,7 +117,10 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         this.outlineViewService.publish(roots || []);
     }
 
-    protected async createRoots(model: monaco.editor.IModel, token: CancellationToken, editorSelection?: Range): Promise<MonacoOutlineSymbolInformationNode[]> {
+    protected async createRoots(
+        model: monaco.editor.ITextModel | ITextModel, token: monaco.CancellationToken, editorSelection?: Range
+    ): Promise<MonacoOutlineSymbolInformationNode[]> {
+        model = model as ITextModel;
         if (this.roots && this.roots.length > 0) {
             // Reset the selection on the tree nodes, so that we can apply the new ones based on the `editorSelection`.
             const resetSelection = (node: MonacoOutlineSymbolInformationNode) => {
@@ -128,23 +130,22 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
             this.roots.forEach(resetSelection);
         } else {
             this.roots = [];
-            const providers = DocumentSymbolProviderRegistry.all(model);
+            const providers = StandaloneServices.get(ILanguageFeaturesService).documentSymbolProvider.all(model);
             if (token.isCancellationRequested) {
                 return [];
             }
             const uri = new URI(model.uri.toString());
             for (const provider of providers) {
                 try {
-                    const symbols = await provider.provideDocumentSymbols(model, token);
+                    const symbols = await provider.provideDocumentSymbols(model, token) ?? [];
                     if (token.isCancellationRequested) {
                         return [];
                     }
+                    const nodes = this.createNodes(uri, symbols);
                     if (providers.length > 1 && provider.displayName) {
-                        const nodes = this.createNodes(uri, symbols || []);
-                        const providerRootNode = this.createProviderRootNode(uri, provider.displayName, nodes);
-                        this.roots.push(providerRootNode);
+                        const providerRoot = this.createProviderRootNode(uri, provider.displayName, nodes);
+                        this.roots.push(providerRoot);
                     } else {
-                        const nodes = this.createNodes(uri, symbols || []);
                         this.roots.push(...nodes);
                     }
                 } catch {
@@ -172,7 +173,8 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         return node;
     }
 
-    protected createNodes(uri: URI, symbols: DocumentSymbol[]): MonacoOutlineSymbolInformationNode[] {
+    protected createNodes(uri: URI, symbols: monaco.languages.DocumentSymbol[] | DocumentSymbol[]): MonacoOutlineSymbolInformationNode[] {
+        symbols = symbols as monaco.languages.DocumentSymbol[];
         let rangeBased = false;
         const ids = new Map();
         const roots: MonacoOutlineSymbolInformationNode[] = [];
@@ -237,7 +239,7 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
      *
      * If the argument is a `DocumentSymbol`, then `getFullRange` will be used to retrieve the range of the underlying symbol.
      */
-    protected parentContains(candidate: DocumentSymbol | Range, parent: DocumentSymbol | Range, rangeBased: boolean): boolean {
+    protected parentContains(candidate: monaco.languages.DocumentSymbol | Range, parent: monaco.languages.DocumentSymbol | Range, rangeBased: boolean): boolean {
         // TODO: move this code to the `monaco-languageclient`: https://github.com/eclipse-theia/theia/pull/2885#discussion_r217800446
         const candidateRange = Range.is(candidate) ? candidate : this.getFullRange(candidate);
         const parentRange = Range.is(parent) ? parent : this.getFullRange(parent);
@@ -275,7 +277,7 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
      *
      * See: [`DocumentSymbol#range`](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) for more details.
      */
-    protected getFullRange(documentSymbol: DocumentSymbol): Range {
+    protected getFullRange(documentSymbol: monaco.languages.DocumentSymbol): Range {
         return this.asRange(documentSymbol.range);
     }
 
@@ -284,17 +286,19 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
      *
      * See: [`DocumentSymbol#selectionRange`](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) for more details.
      */
-    protected getNameRange(documentSymbol: DocumentSymbol): Range {
+    protected getNameRange(documentSymbol: monaco.languages.DocumentSymbol): Range {
         return this.asRange(documentSymbol.selectionRange);
     }
 
-    protected createNode(uri: URI, symbol: DocumentSymbol, ids: Map<string, number>, parent?: MonacoOutlineSymbolInformationNode): MonacoOutlineSymbolInformationNode {
+    protected createNode(
+        uri: URI, symbol: monaco.languages.DocumentSymbol, ids: Map<string, number>, parent?: MonacoOutlineSymbolInformationNode
+    ): MonacoOutlineSymbolInformationNode {
         const id = this.createId(symbol.name, ids);
         const children: MonacoOutlineSymbolInformationNode[] = [];
         const node: MonacoOutlineSymbolInformationNode = {
             children,
             id,
-            iconClass: SymbolKind[symbol.kind].toString().toLowerCase(),
+            iconClass: monaco.languages.SymbolKind[symbol.kind].toString().toLowerCase(),
             name: this.getName(symbol),
             detail: this.getDetail(symbol),
             parent,
@@ -312,11 +316,11 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         return node;
     }
 
-    protected getName(symbol: DocumentSymbol): string {
+    protected getName(symbol: monaco.languages.DocumentSymbol): string {
         return symbol.name;
     }
 
-    protected getDetail(symbol: DocumentSymbol): string {
+    protected getDetail(symbol: monaco.languages.DocumentSymbol): string {
         return symbol.detail;
     }
 
@@ -327,17 +331,17 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         return name + '_' + index;
     }
 
-    protected shouldExpand(symbol: DocumentSymbol): boolean {
+    protected shouldExpand(symbol: monaco.languages.DocumentSymbol): boolean {
         return [
-            SymbolKind.Class,
-            SymbolKind.Enum, SymbolKind.File,
-            SymbolKind.Interface, SymbolKind.Module,
-            SymbolKind.Namespace, SymbolKind.Object,
-            SymbolKind.Package, SymbolKind.Struct
+            monaco.languages.SymbolKind.Class,
+            monaco.languages.SymbolKind.Enum, monaco.languages.SymbolKind.File,
+            monaco.languages.SymbolKind.Interface, monaco.languages.SymbolKind.Module,
+            monaco.languages.SymbolKind.Namespace, monaco.languages.SymbolKind.Object,
+            monaco.languages.SymbolKind.Package, monaco.languages.SymbolKind.Struct
         ].indexOf(symbol.kind) !== -1;
     }
 
-    protected orderByPosition(symbol: DocumentSymbol, symbol2: DocumentSymbol): number {
+    protected orderByPosition(symbol: monaco.languages.DocumentSymbol, symbol2: monaco.languages.DocumentSymbol): number {
         const startLineComparison = symbol.range.startLineNumber - symbol2.range.startLineNumber;
         if (startLineComparison !== 0) {
             return startLineComparison;
@@ -357,7 +361,7 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
 export namespace MonacoOutlineContribution {
     export interface NodeAndSymbol {
         node: MonacoOutlineSymbolInformationNode;
-        symbol: DocumentSymbol
+        symbol: monaco.languages.DocumentSymbol
     }
 }
 

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

@@ -19,22 +19,37 @@ import { QuickAccessProviderDescriptor, QuickAccessRegistry } from '@theia/core/
 import { CancellationToken, Disposable } from '@theia/core/lib/common';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { MonacoQuickPickItem } from './monaco-quick-input-service';
+import {
+    IPickerQuickAccessProviderOptions, PickerQuickAccessProvider, Picks, Pick, IPickerQuickAccessItem
+} from '@theia/monaco-editor-core/esm/vs/platform/quickinput/browser/pickerQuickAccess';
+import {
+    Extensions,
+    IQuickAccessProvider,
+    IQuickAccessProviderDescriptor,
+    IQuickAccessProviderHelp,
+    IQuickAccessRegistry,
+    QuickAccessRegistry as VSCodeQuickAccessRegistry,
+} from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickAccess';
+import { IQuickPickItem, IQuickPickItemWithResource } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickInput';
+import { Registry } from '@theia/monaco-editor-core/esm/vs/platform/registry/common/platform';
 
-abstract class MonacoPickerAccessProvider extends monaco.quickInput.PickerQuickAccessProvider<QuickPickItem> {
-    constructor(prefix: string, options?: monaco.quickInput.IPickerQuickAccessProviderOptions<QuickPickItem>) {
+interface IAnythingQuickPickItem extends IPickerQuickAccessItem, IQuickPickItemWithResource { }
+
+abstract class MonacoPickerAccessProvider extends PickerQuickAccessProvider<IQuickPickItem> {
+    constructor(prefix: string, options?: IPickerQuickAccessProviderOptions<IQuickPickItem>) {
         super(prefix, options);
     }
 
     abstract getDescriptor(): QuickAccessProviderDescriptor;
 }
 
-class TheiaQuickAccessDescriptor implements monaco.quickInput.IQuickAccessProviderDescriptor {
+class TheiaQuickAccessDescriptor implements IQuickAccessProviderDescriptor {
     constructor(
         public readonly theiaDescriptor: QuickAccessProviderDescriptor,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        readonly ctor: { new(...services: any /* TS BrandedService but no clue how to type this properly */[]): monaco.quickInput.IQuickAccessProvider },
+        readonly ctor: { new(...services: any /* TS BrandedService but no clue how to type this properly */[]): IQuickAccessProvider },
         readonly prefix: string,
-        readonly helpEntries: monaco.quickInput.IQuickAccessProviderHelp[],
+        readonly helpEntries: IQuickAccessProviderHelp[],
         readonly placeholder?: string) { }
 }
 
@@ -43,12 +58,12 @@ export class MonacoQuickAccessRegistry implements QuickAccessRegistry {
     @inject(KeybindingRegistry)
     protected readonly keybindingRegistry: KeybindingRegistry;
 
-    private get monacoRegistry(): monaco.quickInput.IQuickAccessRegistry {
-        return monaco.platform.Registry.as<monaco.quickInput.IQuickAccessRegistry>('workbench.contributions.quickaccess');
+    private get monacoRegistry(): IQuickAccessRegistry {
+        return Registry.as<IQuickAccessRegistry>(Extensions.Quickaccess);
     }
 
     registerQuickAccessProvider(descriptor: QuickAccessProviderDescriptor): Disposable {
-        const toMonacoPick = (item: QuickPickItem): monaco.quickInput.Pick<monaco.quickInput.IAnythingQuickPickItem> => {
+        const toMonacoPick = (item: QuickPickItem): Pick<IAnythingQuickPickItem> => {
             if (QuickPickSeparator.is(item)) {
                 return item;
             } else {
@@ -65,16 +80,9 @@ export class MonacoQuickAccessRegistry implements QuickAccessRegistry {
                     super(descriptor.prefix);
                 }
 
-                override getPicks(
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    filter: string, disposables: any, token: CancellationToken
-                ): monaco.quickInput.Picks<QuickPickItem> | Promise<monaco.quickInput.Picks<QuickPickItem>> {
-                    const result = descriptor.getInstance().getPicks(filter, token);
-                    if (result instanceof Promise) {
-                        return result.then(picks => picks.map(toMonacoPick));
-                    } else {
-                        return result.map(toMonacoPick);
-                    }
+                protected override async _getPicks(filter: string, disposables: unknown, token: CancellationToken): Promise<Picks<IQuickPickItem>> {
+                    const result = await Promise.resolve(descriptor.getInstance().getPicks(filter, token));
+                    return result.map(toMonacoPick);
                 }
             };
 
@@ -97,6 +105,8 @@ export class MonacoQuickAccessRegistry implements QuickAccessRegistry {
         return monacoDescriptor ? (monacoDescriptor as TheiaQuickAccessDescriptor).theiaDescriptor : undefined;
     }
     clear(): void {
-        this.monacoRegistry.clear();
+        if (this.monacoRegistry instanceof VSCodeQuickAccessRegistry) {
+            this.monacoRegistry.clear();
+        }
     }
 }