@theia/monaco 1.48.3 → 1.49.0

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

@@ -0,0 +1,233 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { Position, Range } from '@theia/core/shared/vscode-languageserver-protocol';
+import { DisposableCollection } from '@theia/core';
+import { MonacoEditor } from './monaco-editor';
+import * as monaco from '@theia/monaco-editor-core';
+import { PeekViewWidget, IPeekViewOptions, IPeekViewStyles } from '@theia/monaco-editor-core/esm/vs/editor/contrib/peekView/browser/peekView';
+import { ICodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
+import { ActionBar } from '@theia/monaco-editor-core/esm/vs/base/browser/ui/actionbar/actionbar';
+import { Action } from '@theia/monaco-editor-core/esm/vs/base/common/actions';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { Color } from '@theia/monaco-editor-core/esm/vs/base/common/color';
+
+export { peekViewBorder, peekViewTitleBackground, peekViewTitleForeground, peekViewTitleInfoForeground }
+    from '@theia/monaco-editor-core/esm/vs/editor/contrib/peekView/browser/peekView';
+
+export namespace MonacoEditorPeekViewWidget {
+    export interface Styles {
+        frameColor?: string;
+        arrowColor?: string;
+        headerBackgroundColor?: string;
+        primaryHeadingColor?: string;
+        secondaryHeadingColor?: string;
+    }
+    export interface Options {
+        showFrame?: boolean;
+        showArrow?: boolean;
+        frameWidth?: number;
+        className?: string;
+        isAccessible?: boolean;
+        isResizeable?: boolean;
+        keepEditorSelection?: boolean;
+        allowUnlimitedHeight?: boolean;
+        ordinal?: number;
+        showInHiddenAreas?: boolean;
+        supportOnTitleClick?: boolean;
+    }
+    export interface Action {
+        readonly id: string;
+        label: string;
+        tooltip: string;
+        class: string | undefined;
+        enabled: boolean;
+        checked?: boolean;
+        run(...args: unknown[]): unknown;
+    }
+    export interface ActionOptions {
+        icon?: boolean;
+        label?: boolean;
+        keybinding?: string;
+        index?: number;
+    }
+}
+
+export class MonacoEditorPeekViewWidget {
+
+    protected readonly toDispose = new DisposableCollection();
+
+    readonly onDidClose = this.toDispose.onDispose;
+
+    private readonly themeService = StandaloneServices.get(IThemeService);
+
+    private readonly delegate;
+
+    constructor(
+        readonly editor: MonacoEditor,
+        options: MonacoEditorPeekViewWidget.Options = {},
+        protected styles: MonacoEditorPeekViewWidget.Styles = {}
+    ) {
+        const that = this;
+        this.toDispose.push(this.delegate = new class extends PeekViewWidget {
+
+            get actionBar(): ActionBar | undefined {
+                return this._actionbarWidget;
+            }
+
+            fillHead(container: HTMLElement, noCloseAction?: boolean): void {
+                super._fillHead(container, noCloseAction);
+            }
+
+            protected override _fillHead(container: HTMLElement, noCloseAction?: boolean): void {
+                that.fillHead(container, noCloseAction);
+            }
+
+            fillBody(container: HTMLElement): void {
+                // super._fillBody is an abstract method
+            }
+
+            protected override _fillBody(container: HTMLElement): void {
+                that.fillBody(container);
+            };
+
+            doLayoutHead(heightInPixel: number, widthInPixel: number): void {
+                super._doLayoutHead(heightInPixel, widthInPixel);
+            }
+
+            protected override _doLayoutHead(heightInPixel: number, widthInPixel: number): void {
+                that.doLayoutHead(heightInPixel, widthInPixel);
+            }
+
+            doLayoutBody(heightInPixel: number, widthInPixel: number): void {
+                super._doLayoutBody(heightInPixel, widthInPixel);
+            }
+
+            protected override _doLayoutBody(heightInPixel: number, widthInPixel: number): void {
+                that.doLayoutBody(heightInPixel, widthInPixel);
+            }
+
+            onWidth(widthInPixel: number): void {
+                super._onWidth(widthInPixel);
+            }
+
+            protected override _onWidth(widthInPixel: number): void {
+                that.onWidth(widthInPixel);
+            }
+
+            doRevealRange(range: monaco.Range, isLastLine: boolean): void {
+                super.revealRange(range, isLastLine);
+            }
+
+            protected override revealRange(range: monaco.Range, isLastLine: boolean): void {
+                that.doRevealRange(that.editor['m2p'].asRange(range), isLastLine);
+            }
+        }(
+            editor.getControl() as unknown as ICodeEditor,
+            Object.assign(<IPeekViewOptions>{}, options, this.convertStyles(styles)),
+            StandaloneServices.get(IInstantiationService)
+        ));
+        this.toDispose.push(this.themeService.onDidColorThemeChange(() => this.style(this.styles)));
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    create(): void {
+        this.delegate.create();
+    }
+
+    setTitle(primaryHeading: string, secondaryHeading?: string): void {
+        this.delegate.setTitle(primaryHeading, secondaryHeading);
+    }
+
+    style(styles: MonacoEditorPeekViewWidget.Styles): void {
+        this.delegate.style(this.convertStyles(this.styles = styles));
+    }
+
+    show(rangeOrPos: Range | Position, heightInLines: number): void {
+        this.delegate.show(this.convertRangeOrPosition(rangeOrPos), heightInLines);
+    }
+
+    hide(): void {
+        this.delegate.hide();
+    }
+
+    clearActions(): void {
+        this.delegate.actionBar?.clear();
+    }
+
+    addAction(id: string, label: string, cssClass: string | undefined, enabled: boolean, actionCallback: (arg: unknown) => unknown,
+        options?: MonacoEditorPeekViewWidget.ActionOptions): MonacoEditorPeekViewWidget.Action {
+        options = cssClass ? { icon: true, label: false, ...options } : { icon: false, label: true, ...options };
+        const { actionBar } = this.delegate;
+        if (!actionBar) {
+            throw new Error('Action bar has not been created.');
+        }
+        const action = new Action(id, label, cssClass, enabled, actionCallback);
+        actionBar.push(action, options);
+        return action;
+    }
+
+    protected fillHead(container: HTMLElement, noCloseAction?: boolean): void {
+        this.delegate.fillHead(container, noCloseAction);
+    }
+
+    protected fillBody(container: HTMLElement): void {
+        this.delegate.fillBody(container);
+    }
+
+    protected doLayoutHead(heightInPixel: number, widthInPixel: number): void {
+        this.delegate.doLayoutHead(heightInPixel, widthInPixel);
+    }
+
+    protected doLayoutBody(heightInPixel: number, widthInPixel: number): void {
+        this.delegate.doLayoutBody(heightInPixel, widthInPixel);
+    }
+
+    protected onWidth(widthInPixel: number): void {
+        this.delegate.onWidth(widthInPixel);
+    }
+
+    protected doRevealRange(range: Range, isLastLine: boolean): void {
+        this.delegate.doRevealRange(this.editor['p2m'].asRange(range), isLastLine);
+    }
+
+    private convertStyles(styles: MonacoEditorPeekViewWidget.Styles): IPeekViewStyles {
+        return {
+            frameColor: this.convertColor(styles.frameColor),
+            arrowColor: this.convertColor(styles.arrowColor),
+            headerBackgroundColor: this.convertColor(styles.headerBackgroundColor),
+            primaryHeadingColor: this.convertColor(styles.primaryHeadingColor),
+            secondaryHeadingColor: this.convertColor(styles.secondaryHeadingColor),
+        };
+    }
+
+    private convertColor(color?: string): Color | undefined {
+        if (color === undefined) {
+            return undefined;
+        }
+        return this.themeService.getColorTheme().getColor(color) || Color.fromHex(color);
+    }
+
+    private convertRangeOrPosition(arg: Range | Position): monaco.Range | monaco.Position {
+        const p2m = this.editor['p2m'];
+        return Range.is(arg) ? p2m.asRange(arg) : p2m.asPosition(arg);
+    }
+}

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

@@ -211,7 +211,7 @@ export class MonacoEditorProvider {
         return editor;
     }
 
-    protected updateReadOnlyMessage(options: MonacoEditor.IOptions, readOnly: boolean | MarkdownString ): void {
+    protected updateReadOnlyMessage(options: MonacoEditor.IOptions, readOnly: boolean | MarkdownString): void {
         options.readOnlyMessage = MarkdownString.is(readOnly) ? readOnly : undefined;
     }
 
@@ -415,4 +415,41 @@ export class MonacoEditorProvider {
         }
     };
 
+    async createEmbeddedDiffEditor(parentEditor: MonacoEditor, node: HTMLElement, originalUri: URI, modifiedUri: URI = parentEditor.uri,
+        options?: MonacoDiffEditor.IOptions): Promise<MonacoDiffEditor> {
+        options = {
+            scrollBeyondLastLine: true,
+            overviewRulerLanes: 2,
+            fixedOverflowWidgets: true,
+            minimap: { enabled: false },
+            renderSideBySide: false,
+            readOnly: true,
+            renderIndicators: false,
+            diffAlgorithm: 'advanced',
+            stickyScroll: { enabled: false },
+            ...options,
+            scrollbar: {
+                verticalScrollbarSize: 14,
+                horizontal: 'auto',
+                useShadows: true,
+                verticalHasArrows: false,
+                horizontalHasArrows: false,
+                ...options?.scrollbar
+            }
+        };
+        const uri = DiffUris.encode(originalUri, modifiedUri);
+        return await this.doCreateEditor(uri, async (override, toDispose) =>
+            new MonacoDiffEditor(
+                uri,
+                node,
+                await this.getModel(originalUri, toDispose),
+                await this.getModel(modifiedUri, toDispose),
+                this.services,
+                this.diffNavigatorFactory,
+                options,
+                override,
+                parentEditor
+            )
+        ) as MonacoDiffEditor;
+    }
 }

package/src/browser/monaco-editor.ts

@@ -48,9 +48,20 @@ import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/stan
 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, IMouseTargetMargin } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
-import { IStandaloneEditorConstructionOptions, StandaloneEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
+import { IStandaloneEditorConstructionOptions, StandaloneCodeEditor, StandaloneEditor } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor';
 import { ServiceCollection } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/serviceCollection';
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
+import { ConfigurationChangedEvent, IEditorOptions } from '@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
+import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
+import { ICommandService } from '@theia/monaco-editor-core/esm/vs/platform/commands/common/commands';
+import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+import { IKeybindingService } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding';
+import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { INotificationService } from '@theia/monaco-editor-core/esm/vs/platform/notification/common/notification';
+import { IAccessibilityService } from '@theia/monaco-editor-core/esm/vs/platform/accessibility/common/accessibility';
+import { ILanguageConfigurationService } from '@theia/monaco-editor-core/esm/vs/editor/common/languages/languageConfigurationRegistry';
+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';
 
 export type ServicePair<T> = [ServiceIdentifier<T>, T];
 
@@ -103,7 +114,8 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         readonly node: HTMLElement,
         services: MonacoEditorServices,
         options?: MonacoEditor.IOptions,
-        override?: EditorServiceOverrides
+        override?: EditorServiceOverrides,
+        readonly parentEditor?: MonacoEditor
     ) {
         super(services);
         this.toDispose.pushAll([
@@ -153,7 +165,9 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
          * @monaco-uplift. Should be guaranteed to work.
          * Incomparable enums prevent TypeScript from believing that public IStandaloneCodeEditor is satisfied by private StandaloneCodeEditor
          */
-        return this.editor = instantiator.createInstance(StandaloneEditor, this.node, combinedOptions) as unknown as monaco.editor.IStandaloneCodeEditor;
+        return this.editor = (this.parentEditor ?
+            instantiator.createInstance(EmbeddedCodeEditor, this.node, combinedOptions, this.parentEditor.getControl() as unknown as ICodeEditor) :
+            instantiator.createInstance(StandaloneEditor, this.node, combinedOptions)) as unknown as monaco.editor.IStandaloneCodeEditor;
     }
 
     protected getInstantiatorWithOverrides(override?: EditorServiceOverrides): IInstantiationService {
@@ -589,6 +603,9 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         return this.uri.withPath(resourceUri.path);
     }
 
+    shouldDisplayDirtyDiff(): boolean {
+        return true;
+    }
 }
 
 export namespace MonacoEditor {
@@ -661,3 +678,52 @@ export namespace MonacoEditor {
         return {};
     }
 }
+
+// adapted from https://github.com/microsoft/vscode/blob/0bd70d48ad8b3e2fb1922aa54f87c786ff2b4bd8/src/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget.ts
+// This class reproduces the logic in EmbeddedCodeEditorWidget but extends StandaloneCodeEditor rather than CodeEditorWidget.
+class EmbeddedCodeEditor extends StandaloneCodeEditor {
+
+    private readonly _parentEditor: ICodeEditor;
+    private readonly _overwriteOptions: IEditorOptions;
+
+    constructor(
+        domElement: HTMLElement,
+        options: Readonly<IStandaloneEditorConstructionOptions>,
+        parentEditor: ICodeEditor,
+        @IInstantiationService instantiationService: IInstantiationService,
+        @ICodeEditorService codeEditorService: ICodeEditorService,
+        @ICommandService commandService: ICommandService,
+        @IContextKeyService contextKeyService: IContextKeyService,
+        @IKeybindingService keybindingService: IKeybindingService,
+        @IThemeService themeService: IThemeService,
+        @INotificationService notificationService: INotificationService,
+        @IAccessibilityService accessibilityService: IAccessibilityService,
+        @ILanguageConfigurationService languageConfigurationService: ILanguageConfigurationService,
+        @ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
+    ) {
+        super(domElement, { ...parentEditor.getRawOptions(), overflowWidgetsDomNode: parentEditor.getOverflowWidgetsDomNode() }, instantiationService, codeEditorService,
+            commandService, contextKeyService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
+
+        this._parentEditor = parentEditor;
+        this._overwriteOptions = options;
+
+        // Overwrite parent's options
+        super.updateOptions(this._overwriteOptions);
+
+        this._register(parentEditor.onDidChangeConfiguration((e: ConfigurationChangedEvent) => this._onParentConfigurationChanged(e)));
+    }
+
+    getParentEditor(): ICodeEditor {
+        return this._parentEditor;
+    }
+
+    private _onParentConfigurationChanged(e: ConfigurationChangedEvent): void {
+        super.updateOptions(this._parentEditor.getRawOptions());
+        super.updateOptions(this._overwriteOptions);
+    }
+
+    override updateOptions(newOptions: IEditorOptions): void {
+        objects.mixin(this._overwriteOptions, newOptions, true);
+        super.updateOptions(this._overwriteOptions);
+    }
+}

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

@@ -14,22 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as MonacoNls from '@theia/monaco-editor-core/esm/vs/nls';
-import { nls } from '@theia/core/lib/common/nls';
-import { FormatType, Localization } from '@theia/core/lib/common/i18n/localization';
-
-Object.assign(MonacoNls, {
-    localize(_key: string, label: string, ...args: FormatType[]): string {
-        if (nls.locale) {
-            const defaultKey = nls.getDefaultKey(label);
-            if (defaultKey) {
-                return nls.localize(defaultKey, label, ...args);
-            }
-        }
-        return Localization.format(label, args);
-    }
-});
-
 import '../../src/browser/style/index.css';
 import { ContainerModule, interfaces } from '@theia/core/shared/inversify';
 import { MenuContribution, CommandContribution, quickInputServicePath } from '@theia/core/lib/common';

package/src/browser/monaco-init.ts

@@ -27,6 +27,23 @@
  * is allowed.
  */
 
+// Before importing anything from monaco we need to override its localization function
+import * as MonacoNls from '@theia/monaco-editor-core/esm/vs/nls';
+import { nls } from '@theia/core/lib/common/nls';
+import { FormatType, Localization } from '@theia/core/lib/common/i18n/localization';
+
+Object.assign(MonacoNls, {
+    localize(_key: string, label: string, ...args: FormatType[]): string {
+        if (nls.locale) {
+            const defaultKey = nls.getDefaultKey(label);
+            if (defaultKey) {
+                return nls.localize(defaultKey, label, ...args);
+            }
+        }
+        return Localization.format(label, args);
+    }
+});
+
 import { Container } from '@theia/core/shared/inversify';
 import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';

package/src/browser/monaco-menu.ts

@@ -14,12 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject } from '@theia/core/shared/inversify';
-import { MenuContribution, MenuModelRegistry, MAIN_MENU_BAR, MenuPath, MenuAction } from '@theia/core/lib/common';
-import { EditorMainMenu, EDITOR_CONTEXT_MENU } from '@theia/editor/lib/browser';
-import { MonacoCommandRegistry } from './monaco-command-registry';
+import { MAIN_MENU_BAR, MenuAction, MenuContribution, MenuModelRegistry, MenuPath } from '@theia/core/lib/common';
 import { nls } from '@theia/core/lib/common/nls';
-import { IMenuItem, isIMenuItem, MenuId, MenuRegistry } from '@theia/monaco-editor-core/esm/vs/platform/actions/common/actions';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { EDITOR_CONTEXT_MENU, EditorMainMenu } from '@theia/editor/lib/browser';
+import { IMenuItem, MenuId, MenuRegistry, isIMenuItem } from '@theia/monaco-editor-core/esm/vs/platform/actions/common/actions';
+import { MonacoCommands } from './monaco-command';
+import { MonacoCommandRegistry } from './monaco-command-registry';
 
 export interface MonacoActionGroup {
     id: string;
@@ -46,7 +47,11 @@ export class MonacoEditorMenuContribution implements MenuContribution {
             const commandId = this.commands.validate(item.command.id);
             if (commandId) {
                 const menuPath = [...EDITOR_CONTEXT_MENU, (item.group || '')];
-                registry.registerMenuAction(menuPath, this.buildMenuAction(commandId, item));
+                const coreId = MonacoCommands.COMMON_ACTIONS.get(commandId);
+                if (!(coreId && registry.getMenu(menuPath).children.some(it => it.id === coreId))) {
+                    // Don't add additional actions if the item is already registered with a core ID.
+                    registry.registerMenuAction(menuPath, this.buildMenuAction(commandId, item));
+                }
             }
         }
 

package/src/browser/style/index.css

@@ -21,7 +21,6 @@
 .monaco-editor .zone-widget {
   position: absolute;
   z-index: 10;
-  background-color: var(--theia-editorWidget-background);
 }
 
 .monaco-editor .zone-widget .zone-widget-container {