@theia/monaco 1.60.0-next.43 → 1.60.0

package/src/browser/monaco-editor-peek-view-widget.ts

@@ -90,6 +90,14 @@ export class MonacoEditorPeekViewWidget {
                 return this._actionbarWidget;
             }
 
+            fillContainer(container: HTMLElement): void {
+                super._fillContainer(container);
+            }
+
+            protected override _fillContainer(container: HTMLElement): void {
+                that.fillContainer(container);
+            }
+
             fillHead(container: HTMLElement, noCloseAction?: boolean): void {
                 super._fillHead(container, noCloseAction);
             }
@@ -137,6 +145,26 @@ export class MonacoEditorPeekViewWidget {
             protected override revealRange(range: monaco.Range, isLastLine: boolean): void {
                 that.doRevealRange(that.editor['m2p'].asRange(range), isLastLine);
             }
+
+            getBodyElement(): HTMLDivElement | undefined {
+                return this._bodyElement;
+            }
+
+            setBodyElement(element: HTMLDivElement | undefined): void {
+                this._bodyElement = element;
+            }
+
+            getHeadElement(): HTMLDivElement | undefined {
+                return this._headElement;
+            }
+
+            setHeadElement(element: HTMLDivElement | undefined): void {
+                this._headElement = element;
+            }
+
+            override setCssClass(className: string, classToReplace?: string | undefined): void {
+                super.setCssClass(className, classToReplace);
+            }
         }(
             editor.getControl() as unknown as ICodeEditor,
             Object.assign(<IPeekViewOptions>{}, options, this.convertStyles(styles)),
@@ -185,6 +213,10 @@ export class MonacoEditorPeekViewWidget {
         return action;
     }
 
+    protected fillContainer(container: HTMLElement): void {
+        this.delegate.fillContainer(container);
+    }
+
     protected fillHead(container: HTMLElement, noCloseAction?: boolean): void {
         this.delegate.fillHead(container, noCloseAction);
     }
@@ -209,6 +241,26 @@ export class MonacoEditorPeekViewWidget {
         this.delegate.doRevealRange(this.editor['p2m'].asRange(range), isLastLine);
     }
 
+    protected get bodyElement(): HTMLDivElement | undefined {
+        return this.delegate.getBodyElement();
+    }
+
+    protected set bodyElement(element: HTMLDivElement | undefined) {
+        this.delegate.setBodyElement(element);
+    }
+
+    protected get headElement(): HTMLDivElement | undefined {
+        return this.delegate.getHeadElement();
+    }
+
+    protected set headElement(element: HTMLDivElement | undefined) {
+        this.delegate.setHeadElement(element);
+    }
+
+    protected setCssClass(className: string, classToReplace?: string | undefined): void {
+        this.delegate.setCssClass(className, classToReplace);
+    }
+
     private convertStyles(styles: MonacoEditorPeekViewWidget.Styles): IPeekViewStyles {
         return {
             frameColor: this.convertColor(styles.frameColor),

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

@@ -409,7 +409,7 @@ export class MonacoEditorProvider {
         overviewRulerBorder: false,
         scrollBeyondLastLine: false,
         renderLineHighlight: 'none',
-        fixedOverflowWidgets: false,
+        fixedOverflowWidgets: true,
         acceptSuggestionOnEnter: 'smart',
         minimap: {
             enabled: false
@@ -421,10 +421,10 @@ export class MonacoEditorProvider {
         options = {
             scrollBeyondLastLine: true,
             overviewRulerLanes: 2,
-            fixedOverflowWidgets: false,
+            fixedOverflowWidgets: true,
             minimap: { enabled: false },
             renderSideBySide: false,
-            readOnly: true,
+            readOnly: false,
             renderIndicators: false,
             diffAlgorithm: 'advanced',
             stickyScroll: { enabled: false },

package/src/browser/monaco-editor.ts

@@ -63,7 +63,8 @@ import { ILanguageConfigurationService } from '@theia/monaco-editor-core/esm/vs/
 import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
 import * as objects from '@theia/monaco-editor-core/esm/vs/base/common/objects';
 import { Selection } from '@theia/editor/lib/browser/editor';
-import { IHoverService } from '@theia/monaco-editor-core/esm/vs/platform/hover/browser/hover';
+import { IHoverService, WorkbenchHoverDelegate } from '@theia/monaco-editor-core/esm/vs/platform/hover/browser/hover';
+import { setHoverDelegateFactory } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/hover/hoverDelegateFactory';
 import { MonacoTextModelService } from './monaco-text-model-service';
 
 export type ServicePair<T> = [ServiceIdentifier<T>, T];
@@ -155,6 +156,11 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
             ...MonacoEditor.createReadOnlyOptions(document.readOnly),
             ...options
         }, override));
+        // Ensure that a valid InstantiationService is responsible for creating hover delegates when the InstantiationService for this widget is disposed.
+        // Cf. https://github.com/eclipse-theia/theia/issues/15102
+        this.toDispose.push(Disposable.create(() => setHoverDelegateFactory((placement, enableInstantHover) =>
+            StandaloneServices.get(IInstantiationService).createInstance(WorkbenchHoverDelegate, placement, enableInstantHover, {})
+        )));
         this.addHandlers(this.editor);
     }
 
@@ -174,7 +180,7 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         const combinedOptions = {
             ...options,
             lightbulb: { enabled: ShowLightbulbIconMode.On },
-            fixedOverflowWidgets: false,
+            fixedOverflowWidgets: true,
             scrollbar: {
                 useShadows: false,
                 verticalHasArrows: false,
@@ -198,7 +204,9 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         const instantiator = StandaloneServices.get(IInstantiationService);
         if (override) {
             const overrideServices = new ServiceCollection(...override);
-            return instantiator.createChild(overrideServices);
+            const child = instantiator.createChild(overrideServices);
+            this.toDispose.push(child);
+            return child;
         }
         return instantiator;
     }

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

@@ -78,6 +78,7 @@ import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/c
 import { ActiveMonacoUndoRedoHandler, FocusedMonacoUndoRedoHandler } from './monaco-undo-redo-handler';
 import { ILogService } from '@theia/monaco-editor-core/esm/vs/platform/log/common/log';
 import { DefaultContentHoverWidgetPatcher } from './default-content-hover-widget-patcher';
+import { MonacoWorkspaceContextService } from './monaco-workspace-context-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoThemingService).toSelf().inSingletonScope();
@@ -101,6 +102,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     }
 
     bind(MonacoWorkspace).toSelf().inSingletonScope();
+    bind(MonacoWorkspaceContextService).toSelf().inSingletonScope();
 
     bind(MonacoConfigurationService).toDynamicValue(({ container }) => createMonacoConfigurationService(container)).inSingletonScope();
 
@@ -221,6 +223,12 @@ export function createMonacoConfigurationService(container: interfaces.Container
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     service.updateValues = (values: [string, any][]) => Promise.resolve();
 
+    /*
+     * There are a few places in Monaco where this method is called from, including actions for editor minimap in `ContextMenuController`.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    service.updateValue = (key: string, value: any) => preferences.updateValue(key, value);
+
     const toTarget = (scope: PreferenceScope): ConfigurationTarget => {
         switch (scope) {
             case PreferenceScope.Default: return ConfigurationTarget.DEFAULT;

package/src/browser/monaco-init.ts

@@ -82,6 +82,8 @@ import { MonacoStandaloneThemeService } from './monaco-standalone-theme-service'
 import { createContentHoverWidgetPatcher } from './content-hover-widget-patcher';
 import { IHoverService } from '@theia/monaco-editor-core/esm/vs/platform/hover/browser/hover';
 import { setBaseLayerHoverDelegate } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/hover/hoverDelegate2';
+import { IWorkspaceContextService } from '@theia/monaco-editor-core/esm/vs/platform/workspace/common/workspace';
+import { MonacoWorkspaceContextService } from './monaco-workspace-context-service';
 
 export const contentHoverWidgetPatcher = createContentHoverWidgetPatcher();
 
@@ -143,6 +145,12 @@ class MonacoStandaloneThemeServiceConstructor {
     }
 }
 
+class MonacoWorkspaceContextServiceConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoWorkspaceContextService);
+    }
+}
+
 export namespace MonacoInit {
     export function init(container: Container): void {
         StandaloneServices.initialize({
@@ -153,7 +161,8 @@ export namespace MonacoInit {
             [IBulkEditService.toString()]: new SyncDescriptor(MonacoBulkEditServiceConstructor, [container]),
             [ICommandService.toString()]: new SyncDescriptor(MonacoCommandServiceConstructor, [container]),
             [IQuickInputService.toString()]: new SyncDescriptor(MonacoQuickInputImplementationConstructor, [container]),
-            [IStandaloneThemeService.toString()]: new SyncDescriptor(MonacoStandaloneThemeServiceConstructor, [])
+            [IStandaloneThemeService.toString()]: new SyncDescriptor(MonacoStandaloneThemeServiceConstructor, []),
+            [IWorkspaceContextService.toString()]: new SyncDescriptor(MonacoWorkspaceContextServiceConstructor, [container])
         });
         // Make sure the global base hover delegate is initialized as otherwise the quick input will throw an error and not update correctly
         // in case no Monaco editor was constructed before and items with keybindings are shown. See #15042.

package/src/browser/monaco-workspace-context-service.ts

@@ -0,0 +1,79 @@
+// *****************************************************************************
+// Copyright (C) 2025 1C-Soft LLC and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { Emitter } from '@theia/monaco-editor-core/esm/vs/base/common/event';
+import { URI } from '@theia/monaco-editor-core/esm/vs/base/common/uri';
+import {
+    ISingleFolderWorkspaceIdentifier,
+    IWorkspace,
+    IWorkspaceContextService,
+    IWorkspaceFolder,
+    IWorkspaceFoldersChangeEvent,
+    IWorkspaceFoldersWillChangeEvent,
+    IWorkspaceIdentifier,
+    UNKNOWN_EMPTY_WINDOW_WORKSPACE,
+    WorkbenchState
+} from '@theia/monaco-editor-core/esm/vs/platform/workspace/common/workspace';
+
+/**
+ * A minimal implementation of {@link IWorkspaceContextService} to replace the `StandaloneWorkspaceContextService` in Monaco
+ * as a workaround for the issue of showing no context menu for editor minimap (#15217).
+ */
+@injectable()
+export class MonacoWorkspaceContextService implements IWorkspaceContextService {
+
+    declare readonly _serviceBrand: undefined;
+
+    protected readonly onDidChangeWorkbenchStateEmitter = new Emitter<WorkbenchState>();
+    readonly onDidChangeWorkbenchState = this.onDidChangeWorkbenchStateEmitter.event;
+
+    protected readonly onDidChangeWorkspaceNameEmitter = new Emitter<void>();
+    readonly onDidChangeWorkspaceName = this.onDidChangeWorkspaceNameEmitter.event;
+
+    protected readonly onWillChangeWorkspaceFoldersEmitter = new Emitter<IWorkspaceFoldersWillChangeEvent>();
+    readonly onWillChangeWorkspaceFolders = this.onWillChangeWorkspaceFoldersEmitter.event;
+
+    protected readonly onDidChangeWorkspaceFoldersEmitter = new Emitter<IWorkspaceFoldersChangeEvent>();
+    readonly onDidChangeWorkspaceFolders = this.onDidChangeWorkspaceFoldersEmitter.event;
+
+    protected workspace: IWorkspace = { id: UNKNOWN_EMPTY_WINDOW_WORKSPACE.id, folders: [] };
+
+    getCompleteWorkspace(): Promise<IWorkspace> {
+        return Promise.resolve(this.getWorkspace());
+    }
+
+    getWorkspace(): IWorkspace {
+        return this.workspace;
+    }
+
+    getWorkbenchState(): WorkbenchState {
+        return WorkbenchState.EMPTY;
+    }
+
+    getWorkspaceFolder(resource: URI): IWorkspaceFolder | null {
+        // eslint-disable-next-line no-null/no-null
+        return null;
+    }
+
+    isCurrentWorkspace(workspaceIdOrFolder: IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | URI): boolean {
+        return false;
+    }
+
+    isInsideWorkspace(resource: URI): boolean {
+        return false;
+    }
+}

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

@@ -89,7 +89,7 @@ export class SimpleMonacoEditor extends MonacoEditorServices implements Disposab
         const combinedOptions = {
             ...options,
             lightbulb: { enabled: ShowLightbulbIconMode.On },
-            fixedOverflowWidgets: false,
+            fixedOverflowWidgets: true,
             automaticLayout: true,
             scrollbar: {
                 useShadows: false,

package/src/browser/workspace-symbol-command.ts

@@ -156,7 +156,7 @@ export class WorkspaceSymbolCommand implements QuickAccessProvider, CommandContr
         if (!kind) {
             return undefined;
         }
-        return [`codicon ${inline ? 'inline' : 'block'} codicon-symbol-${kind.toLowerCase() || 'property'}`];
+        return ['codicon', `${inline ? 'inline' : 'block'}`, `codicon-symbol-${kind.toLowerCase() || 'property'}`];
     }
 
     private openURL(uri: URI, start: Position, end: Position): void {